status-go/protocol/persistence.go

1615 lines
36 KiB
Go
Raw Normal View History

package protocol
2019-07-17 22:25:42 +00:00
import (
"bytes"
2019-07-17 22:25:42 +00:00
"context"
"database/sql"
"encoding/gob"
"encoding/json"
"strings"
"time"
2019-07-17 22:25:42 +00:00
"github.com/pkg/errors"
2020-01-15 11:36:49 +00:00
"github.com/ethereum/go-ethereum/log"
"github.com/mat/besticon/besticon"
"github.com/status-im/status-go/eth-node/crypto"
"github.com/status-im/status-go/images"
userimage "github.com/status-im/status-go/images"
2020-07-22 07:41:40 +00:00
"github.com/status-im/status-go/protocol/common"
2022-08-02 12:56:26 +00:00
"github.com/status-im/status-go/protocol/identity"
2020-12-15 14:43:41 +00:00
"github.com/status-im/status-go/protocol/protobuf"
"github.com/status-im/status-go/services/browsers"
2019-07-17 22:25:42 +00:00
)
var (
// ErrMsgAlreadyExist returned if msg already exist.
ErrMsgAlreadyExist = errors.New("message with given ID already exist")
2021-10-28 15:21:28 +00:00
HoursInTwoWeeks = 336
2019-07-17 22:25:42 +00:00
)
// sqlitePersistence wrapper around sql db with operations common for a client.
type sqlitePersistence struct {
*common.RawMessagesPersistence
2019-07-17 22:25:42 +00:00
db *sql.DB
}
2022-03-28 10:10:40 +00:00
func newSQLitePersistence(db *sql.DB) *sqlitePersistence {
return &sqlitePersistence{common.NewRawMessagesPersistence(db), db}
}
func (db sqlitePersistence) SaveChat(chat Chat) error {
err := chat.Validate()
if err != nil {
return err
}
return db.saveChat(nil, chat)
}
2019-07-17 22:25:42 +00:00
func (db sqlitePersistence) SaveChats(chats []*Chat) error {
tx, err := db.db.BeginTx(context.Background(), &sql.TxOptions{})
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
// don't shadow original error
_ = tx.Rollback()
}()
for _, chat := range chats {
err := db.saveChat(tx, *chat)
if err != nil {
return err
}
2019-07-17 22:25:42 +00:00
}
return nil
2019-07-17 22:25:42 +00:00
}
func (db sqlitePersistence) SaveContacts(contacts []*Contact) error {
tx, err := db.db.BeginTx(context.Background(), &sql.TxOptions{})
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
// don't shadow original error
_ = tx.Rollback()
}()
for _, contact := range contacts {
err := db.SaveContact(contact, tx)
if err != nil {
return err
}
}
return nil
}
func (db sqlitePersistence) saveChat(tx *sql.Tx, chat Chat) error {
var err error
if tx == nil {
tx, err = db.db.BeginTx(context.Background(), &sql.TxOptions{})
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
// don't shadow original error
_ = tx.Rollback()
}()
}
// Encode members
var encodedMembers bytes.Buffer
memberEncoder := gob.NewEncoder(&encodedMembers)
if err := memberEncoder.Encode(chat.Members); err != nil {
return err
}
// Encode membership updates
var encodedMembershipUpdates bytes.Buffer
membershipUpdatesEncoder := gob.NewEncoder(&encodedMembershipUpdates)
if err := membershipUpdatesEncoder.Encode(chat.MembershipUpdates); err != nil {
return err
}
// encode last message
var encodedLastMessage []byte
if chat.LastMessage != nil {
encodedLastMessage, err = json.Marshal(chat.LastMessage)
if err != nil {
return err
}
}
// Insert record
2023-04-16 15:06:00 +00:00
stmt, err := tx.Prepare(`INSERT INTO chats(id, name, color, emoji, active, type, timestamp, deleted_at_clock_value, unviewed_message_count, unviewed_mentions_count, last_clock_value, last_message, members, membership_updates, muted, muted_till, invitation_admin, profile, community_id, joined, synced_from, synced_to, first_message_timestamp, description, highlight, read_messages_at_clock_value, received_invitation_admin, image_payload)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?, ?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
if err != nil {
return err
}
defer stmt.Close()
var imagePayload []byte
if len(chat.Base64Image) > 0 {
imagePayload, err = userimage.GetPayloadFromURI(chat.Base64Image)
if err != nil {
return err
}
}
_, err = stmt.Exec(
chat.ID,
chat.Name,
chat.Color,
chat.Emoji,
chat.Active,
chat.ChatType,
chat.Timestamp,
chat.DeletedAtClockValue,
chat.UnviewedMessagesCount,
chat.UnviewedMentionsCount,
chat.LastClockValue,
encodedLastMessage,
encodedMembers.Bytes(),
encodedMembershipUpdates.Bytes(),
2020-06-26 07:46:14 +00:00
chat.Muted,
2023-04-16 15:06:00 +00:00
chat.MuteTill,
2020-08-07 13:49:37 +00:00
chat.InvitationAdmin,
2020-10-20 15:10:28 +00:00
chat.Profile,
chat.CommunityID,
chat.Joined,
2021-05-14 10:55:42 +00:00
chat.SyncedFrom,
chat.SyncedTo,
chat.FirstMessageTimestamp,
chat.Description,
chat.Highlight,
2021-10-12 10:33:32 +00:00
chat.ReadMessagesAtClockValue,
chat.ReceivedInvitationAdmin,
imagePayload,
)
2020-10-20 15:10:28 +00:00
if err != nil {
return err
}
return err
}
2021-03-25 15:15:22 +00:00
func (db sqlitePersistence) SetSyncTimestamps(syncedFrom, syncedTo uint32, chatID string) error {
_, err := db.db.Exec(`UPDATE chats SET synced_from = ?, synced_to = ? WHERE id = ?`, syncedFrom, syncedTo, chatID)
return err
}
func (db sqlitePersistence) DeleteChat(chatID string) (err error) {
var tx *sql.Tx
tx, err = db.db.BeginTx(context.Background(), &sql.TxOptions{})
if err != nil {
return
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
// don't shadow original error
_ = tx.Rollback()
}()
_, err = tx.Exec("DELETE FROM chats WHERE id = ?", chatID)
if err != nil {
return
}
2020-12-22 16:20:12 +00:00
_, err = tx.Exec(`DELETE FROM user_messages WHERE local_chat_id = ?`, chatID)
return
}
2023-04-16 15:06:00 +00:00
func (db sqlitePersistence) MuteChat(chatID string, mutedTill time.Time) error {
mutedTillFormatted := mutedTill.Format(time.RFC3339)
_, err := db.db.Exec("UPDATE chats SET muted = 1, muted_till = ? WHERE id = ?", mutedTillFormatted, chatID)
2020-06-26 07:46:14 +00:00
return err
}
func (db sqlitePersistence) UnmuteChat(chatID string) error {
2023-04-16 15:06:00 +00:00
_, err := db.db.Exec("UPDATE chats SET muted = 0, muted_till = 0 WHERE id = ?", chatID)
2020-06-26 07:46:14 +00:00
return err
}
2019-08-29 06:33:46 +00:00
func (db sqlitePersistence) Chats() ([]*Chat, error) {
return db.chats(nil)
}
func (db sqlitePersistence) chats(tx *sql.Tx) (chats []*Chat, err error) {
if tx == nil {
tx, err = db.db.BeginTx(context.Background(), &sql.TxOptions{})
if err != nil {
return
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
// don't shadow original error
_ = tx.Rollback()
}()
}
rows, err := tx.Query(`
SELECT
chats.id,
chats.name,
chats.color,
chats.emoji,
chats.active,
chats.type,
chats.timestamp,
chats.deleted_at_clock_value,
chats.read_messages_at_clock_value,
chats.unviewed_message_count,
chats.unviewed_mentions_count,
chats.last_clock_value,
chats.last_message,
chats.members,
chats.membership_updates,
2020-06-26 07:46:14 +00:00
chats.muted,
2023-04-16 15:06:00 +00:00
chats.muted_till,
2020-08-07 13:49:37 +00:00
chats.invitation_admin,
2020-10-20 15:10:28 +00:00
chats.profile,
chats.community_id,
2021-03-25 15:15:22 +00:00
chats.joined,
chats.synced_from,
chats.synced_to,
chats.first_message_timestamp,
chats.description,
contacts.alias,
chats.highlight,
chats.received_invitation_admin,
chats.image_payload
FROM chats LEFT JOIN contacts ON chats.id = contacts.id
ORDER BY chats.timestamp DESC
`)
if err != nil {
return
}
defer rows.Close()
for rows.Next() {
var (
alias sql.NullString
2020-08-07 13:49:37 +00:00
invitationAdmin sql.NullString
2020-10-20 15:10:28 +00:00
profile sql.NullString
2021-03-25 15:15:22 +00:00
syncedFrom sql.NullInt64
syncedTo sql.NullInt64
firstMessageTimestamp sql.NullInt64
2023-04-16 15:06:00 +00:00
MuteTill sql.NullTime
chat Chat
encodedMembers []byte
encodedMembershipUpdates []byte
lastMessageBytes []byte
imagePayload []byte
)
err = rows.Scan(
&chat.ID,
&chat.Name,
&chat.Color,
&chat.Emoji,
&chat.Active,
&chat.ChatType,
&chat.Timestamp,
&chat.DeletedAtClockValue,
2021-10-12 10:33:32 +00:00
&chat.ReadMessagesAtClockValue,
&chat.UnviewedMessagesCount,
&chat.UnviewedMentionsCount,
&chat.LastClockValue,
&lastMessageBytes,
&encodedMembers,
&encodedMembershipUpdates,
2020-06-26 07:46:14 +00:00
&chat.Muted,
2023-04-16 15:06:00 +00:00
&MuteTill,
2020-08-07 13:49:37 +00:00
&invitationAdmin,
2020-10-20 15:10:28 +00:00
&profile,
&chat.CommunityID,
&chat.Joined,
2021-03-25 15:15:22 +00:00
&syncedFrom,
&syncedTo,
&firstMessageTimestamp,
&chat.Description,
&alias,
&chat.Highlight,
&chat.ReceivedInvitationAdmin,
&imagePayload,
)
2020-08-07 13:49:37 +00:00
if err != nil {
return
}
2020-08-07 13:49:37 +00:00
if invitationAdmin.Valid {
chat.InvitationAdmin = invitationAdmin.String
}
2020-10-20 15:10:28 +00:00
if profile.Valid {
chat.Profile = profile.String
}
// Restore members
membersDecoder := gob.NewDecoder(bytes.NewBuffer(encodedMembers))
err = membersDecoder.Decode(&chat.Members)
if err != nil {
return
}
// Restore membership updates
membershipUpdatesDecoder := gob.NewDecoder(bytes.NewBuffer(encodedMembershipUpdates))
err = membershipUpdatesDecoder.Decode(&chat.MembershipUpdates)
if err != nil {
return
}
2021-03-25 15:15:22 +00:00
if syncedFrom.Valid {
chat.SyncedFrom = uint32(syncedFrom.Int64)
}
if syncedTo.Valid {
chat.SyncedTo = uint32(syncedTo.Int64)
}
if firstMessageTimestamp.Valid {
chat.FirstMessageTimestamp = uint32(firstMessageTimestamp.Int64)
}
if imagePayload != nil {
base64Image, err := userimage.GetPayloadDataURI(imagePayload)
if err == nil {
chat.Base64Image = base64Image
}
}
// Restore last message
if lastMessageBytes != nil {
message := common.NewMessage()
if err = json.Unmarshal(lastMessageBytes, message); err != nil {
return
}
chat.LastMessage = message
}
2023-04-16 15:06:00 +00:00
if MuteTill.Valid {
chat.MuteTill = MuteTill.Time
}
chat.Alias = alias.String
chats = append(chats, &chat)
}
return
}
func (db sqlitePersistence) Chat(chatID string) (*Chat, error) {
var (
chat Chat
encodedMembers []byte
encodedMembershipUpdates []byte
lastMessageBytes []byte
2020-08-07 13:49:37 +00:00
invitationAdmin sql.NullString
2020-10-20 15:10:28 +00:00
profile sql.NullString
syncedFrom sql.NullInt64
syncedTo sql.NullInt64
firstMessageTimestamp sql.NullInt64
2023-04-16 15:06:00 +00:00
MuteTill sql.NullTime
imagePayload []byte
)
var unviewedMessagesCount int
var unviewedMentionsCount int
err := db.db.QueryRow(`
SELECT
id,
name,
color,
emoji,
active,
type,
timestamp,
2021-10-12 10:33:32 +00:00
read_messages_at_clock_value,
deleted_at_clock_value,
unviewed_message_count,
unviewed_mentions_count,
last_clock_value,
last_message,
members,
2020-06-26 07:46:14 +00:00
membership_updates,
2020-08-07 13:49:37 +00:00
muted,
2023-04-16 15:06:00 +00:00
muted_till,
2020-10-20 15:10:28 +00:00
invitation_admin,
profile,
community_id,
joined,
description,
highlight,
received_invitation_admin,
synced_from,
synced_to,
first_message_timestamp,
image_payload
FROM chats
WHERE id = ?
`, chatID).Scan(&chat.ID,
&chat.Name,
&chat.Color,
&chat.Emoji,
&chat.Active,
&chat.ChatType,
&chat.Timestamp,
2021-10-12 10:33:32 +00:00
&chat.ReadMessagesAtClockValue,
&chat.DeletedAtClockValue,
&unviewedMessagesCount,
&unviewedMentionsCount,
&chat.LastClockValue,
&lastMessageBytes,
&encodedMembers,
&encodedMembershipUpdates,
2020-06-26 07:46:14 +00:00
&chat.Muted,
2023-04-16 15:06:00 +00:00
&MuteTill,
2020-08-07 13:49:37 +00:00
&invitationAdmin,
2020-10-20 15:10:28 +00:00
&profile,
&chat.CommunityID,
&chat.Joined,
&chat.Description,
&chat.Highlight,
&chat.ReceivedInvitationAdmin,
&syncedFrom,
&syncedTo,
&firstMessageTimestamp,
&imagePayload,
)
switch err {
case sql.ErrNoRows:
return nil, nil
case nil:
if syncedFrom.Valid {
chat.SyncedFrom = uint32(syncedFrom.Int64)
}
if syncedTo.Valid {
chat.SyncedTo = uint32(syncedTo.Int64)
}
if firstMessageTimestamp.Valid {
chat.FirstMessageTimestamp = uint32(firstMessageTimestamp.Int64)
}
2020-08-07 13:49:37 +00:00
if invitationAdmin.Valid {
chat.InvitationAdmin = invitationAdmin.String
}
2020-10-20 15:10:28 +00:00
if profile.Valid {
chat.Profile = profile.String
}
// Set UnviewedCounts and make sure they are above 0
// Since Chat's UnviewedMessagesCount is uint and the SQL column is INT, it can create a discrepancy
if unviewedMessagesCount < 0 {
unviewedMessagesCount = 0
}
if unviewedMentionsCount < 0 {
unviewedMentionsCount = 0
}
chat.UnviewedMessagesCount = uint(unviewedMessagesCount)
chat.UnviewedMentionsCount = uint(unviewedMentionsCount)
// Restore members
membersDecoder := gob.NewDecoder(bytes.NewBuffer(encodedMembers))
err = membersDecoder.Decode(&chat.Members)
if err != nil {
return nil, err
}
// Restore membership updates
membershipUpdatesDecoder := gob.NewDecoder(bytes.NewBuffer(encodedMembershipUpdates))
err = membershipUpdatesDecoder.Decode(&chat.MembershipUpdates)
if err != nil {
return nil, err
}
// Restore last message
if lastMessageBytes != nil {
message := common.NewMessage()
if err = json.Unmarshal(lastMessageBytes, message); err != nil {
return nil, err
}
chat.LastMessage = message
}
if imagePayload != nil {
base64Image, err := userimage.GetPayloadDataURI(imagePayload)
if err == nil {
chat.Base64Image = base64Image
}
}
2023-04-16 15:06:00 +00:00
if MuteTill.Valid {
chat.MuteTill = MuteTill.Time
}
return &chat, nil
}
return nil, err
}
func (db sqlitePersistence) Contacts() ([]*Contact, error) {
allContacts := make(map[string]*Contact)
rows, err := db.db.Query(`
SELECT
c.id,
c.address,
2021-01-11 10:32:51 +00:00
v.name,
v.verified,
c.alias,
2022-02-17 15:13:10 +00:00
c.display_name,
c.identicon,
c.last_updated,
c.last_updated_locally,
2021-03-24 08:04:03 +00:00
c.blocked,
c.removed,
c.local_nickname,
2022-08-02 12:56:26 +00:00
c.contact_request_state,
2023-01-20 14:28:30 +00:00
c.contact_request_local_clock,
c.contact_request_remote_state,
c.contact_request_remote_clock,
i.image_type,
i.payload,
2022-07-06 15:19:02 +00:00
i.clock_value,
COALESCE(c.verification_status, 0) as verification_status,
COALESCE(t.trust_status, 0) as trust_status
2022-08-02 12:56:26 +00:00
FROM contacts c
LEFT JOIN chat_identity_contacts i ON c.id = i.contact_id
LEFT JOIN ens_verification_records v ON c.id = v.public_key
LEFT JOIN trusted_users t ON c.id = t.id;
`)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
var (
2023-01-20 14:28:30 +00:00
contact Contact
nickname sql.NullString
contactRequestLocalState sql.NullInt64
contactRequestLocalClock sql.NullInt64
contactRequestRemoteState sql.NullInt64
contactRequestRemoteClock sql.NullInt64
displayName sql.NullString
imageType sql.NullString
ensName sql.NullString
ensVerified sql.NullBool
blocked sql.NullBool
removed sql.NullBool
lastUpdatedLocally sql.NullInt64
identityImageClock sql.NullInt64
imagePayload []byte
)
contact.Images = make(map[string]images.IdentityImage)
err := rows.Scan(
&contact.ID,
&contact.Address,
2021-01-11 10:32:51 +00:00
&ensName,
&ensVerified,
&contact.Alias,
2022-02-17 15:13:10 +00:00
&displayName,
&contact.Identicon,
&contact.LastUpdated,
&lastUpdatedLocally,
2021-03-24 08:04:03 +00:00
&blocked,
&removed,
2020-08-20 14:06:38 +00:00
&nickname,
2023-01-20 14:28:30 +00:00
&contactRequestLocalState,
&contactRequestLocalClock,
&contactRequestRemoteState,
&contactRequestRemoteClock,
&imageType,
&imagePayload,
&identityImageClock,
&contact.VerificationStatus,
&contact.TrustStatus,
)
if err != nil {
return nil, err
}
2020-08-20 14:06:38 +00:00
if nickname.Valid {
contact.LocalNickname = nickname.String
}
2023-01-20 14:28:30 +00:00
if contactRequestLocalState.Valid {
contact.ContactRequestLocalState = ContactRequestState(contactRequestLocalState.Int64)
}
2023-01-20 14:28:30 +00:00
if contactRequestLocalClock.Valid {
contact.ContactRequestLocalClock = uint64(contactRequestLocalClock.Int64)
}
if contactRequestRemoteState.Valid {
contact.ContactRequestRemoteState = ContactRequestState(contactRequestRemoteState.Int64)
}
if contactRequestRemoteClock.Valid {
contact.ContactRequestRemoteClock = uint64(contactRequestRemoteClock.Int64)
}
2022-02-17 15:13:10 +00:00
if displayName.Valid {
contact.DisplayName = displayName.String
}
2021-01-11 10:32:51 +00:00
if ensName.Valid {
2022-02-17 15:13:10 +00:00
contact.EnsName = ensName.String
2021-01-11 10:32:51 +00:00
}
if ensVerified.Valid {
contact.ENSVerified = ensVerified.Bool
}
2021-03-24 08:04:03 +00:00
if blocked.Valid {
contact.Blocked = blocked.Bool
}
if removed.Valid {
contact.Removed = removed.Bool
}
if lastUpdatedLocally.Valid {
contact.LastUpdatedLocally = uint64(lastUpdatedLocally.Int64)
}
previousContact, ok := allContacts[contact.ID]
if !ok {
if imageType.Valid {
contact.Images[imageType.String] = images.IdentityImage{Name: imageType.String, Payload: imagePayload, Clock: uint64(identityImageClock.Int64)}
}
allContacts[contact.ID] = &contact
} else if imageType.Valid {
previousContact.Images[imageType.String] = images.IdentityImage{Name: imageType.String, Payload: imagePayload, Clock: uint64(identityImageClock.Int64)}
allContacts[contact.ID] = previousContact
}
}
2022-08-02 12:56:26 +00:00
// Read social links
for _, contact := range allContacts {
rows, err := db.db.Query(`SELECT link_text, link_url FROM chat_identity_social_links WHERE chat_id = ?`, contact.ID)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
var (
text sql.NullString
url sql.NullString
)
err := rows.Scan(
&text, &url,
)
if err != nil {
return nil, err
}
2023-06-05 11:10:26 +00:00
link := &identity.SocialLink{}
2022-08-02 12:56:26 +00:00
if text.Valid {
link.Text = text.String
}
if url.Valid {
link.URL = url.String
}
contact.SocialLinks = append(contact.SocialLinks, link)
}
}
var response []*Contact
for key := range allContacts {
response = append(response, allContacts[key])
}
return response, nil
}
func extractImageTypes(images map[string]*protobuf.IdentityImage) []string {
uniqueImageTypesMap := make(map[string]struct{})
for key := range images {
uniqueImageTypesMap[key] = struct{}{}
}
var uniqueImageTypes []string
for key := range uniqueImageTypesMap {
uniqueImageTypes = append(uniqueImageTypes, key)
}
return uniqueImageTypes
}
func generatePlaceholders(count int) string {
placeholders := make([]string, count)
for i := 0; i < count; i++ {
placeholders[i] = "?"
}
return strings.Join(placeholders, ", ")
}
func (db sqlitePersistence) UpdateContactChatIdentity(contactID string, chatIdentity *protobuf.ChatIdentity) (clockUpdated, imagesUpdated bool, err error) {
if chatIdentity.Clock == 0 {
2022-08-02 12:56:26 +00:00
return false, false, errors.New("clock value unset")
}
tx, err := db.db.BeginTx(context.Background(), &sql.TxOptions{})
if err != nil {
2022-08-02 12:56:26 +00:00
return false, false, err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
// don't shadow original error
_ = tx.Rollback()
}()
extractedImageTypes := extractImageTypes(chatIdentity.Images)
query := "DELETE FROM chat_identity_contacts WHERE contact_id = ?"
if len(extractedImageTypes) > 0 {
query += " AND image_type NOT IN (" + generatePlaceholders(len(extractedImageTypes)) + ")"
}
stmt, err := tx.Prepare(query)
if err != nil {
return false, false, err
}
defer stmt.Close()
args := make([]interface{}, len(extractedImageTypes)+1)
args[0] = contactID
for i, v := range extractedImageTypes {
args[i+1] = v
}
result, err := stmt.Exec(args...)
if err != nil {
return false, false, err
}
imagesUpdated = false
if rowsAffected, err := result.RowsAffected(); err == nil && rowsAffected > 0 {
imagesUpdated = true
}
2022-08-02 12:56:26 +00:00
updateClock := func() (updated bool, err error) {
var newerClockEntryExists bool
err = tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM chat_identity_last_received WHERE chat_id = ? AND clock_value >= ?)`, contactID, chatIdentity.Clock).Scan(&newerClockEntryExists)
if err != nil {
return false, err
}
if newerClockEntryExists {
return false, nil
}
stmt, err := tx.Prepare("INSERT INTO chat_identity_last_received (chat_id, clock_value) VALUES (?, ?)")
if err != nil {
return false, err
}
defer stmt.Close()
_, err = stmt.Exec(
contactID,
chatIdentity.Clock,
)
if err != nil {
return false, err
}
return true, nil
}
clockUpdated, err = updateClock()
if err != nil {
return false, false, err
}
for imageType, image := range chatIdentity.Images {
var exists bool
err := tx.QueryRow(`SELECT EXISTS(SELECT 1 FROM chat_identity_contacts WHERE contact_id = ? AND image_type = ? AND clock_value >= ?)`, contactID, imageType, chatIdentity.Clock).Scan(&exists)
if err != nil {
2022-08-02 12:56:26 +00:00
return clockUpdated, false, err
}
if exists {
continue
}
stmt, err := tx.Prepare(`INSERT INTO chat_identity_contacts (contact_id, image_type, clock_value, payload) VALUES (?, ?, ?, ?)`)
if err != nil {
2022-08-02 12:56:26 +00:00
return clockUpdated, false, err
}
defer stmt.Close()
if image.Payload == nil {
continue
}
2021-02-17 23:14:48 +00:00
// TODO implement something that doesn't reject all images if a single image fails validation
// Validate image URI to make sure it's serializable
_, err = images.GetPayloadDataURI(image.Payload)
if err != nil {
2022-08-02 12:56:26 +00:00
return clockUpdated, false, err
}
_, err = stmt.Exec(
contactID,
imageType,
chatIdentity.Clock,
image.Payload,
)
if err != nil {
2022-08-02 12:56:26 +00:00
return false, false, err
}
imagesUpdated = true
}
if clockUpdated && chatIdentity.SocialLinks != nil {
stmt, err := tx.Prepare(`INSERT INTO chat_identity_social_links (chat_id, link_text, link_url) VALUES (?, ?, ?)`)
if err != nil {
return clockUpdated, imagesUpdated, err
}
defer stmt.Close()
for _, link := range chatIdentity.SocialLinks {
_, err = stmt.Exec(
contactID,
link.Text,
link.Url,
)
if err != nil {
return clockUpdated, imagesUpdated, err
}
}
}
return
}
func (db sqlitePersistence) ExpiredMessagesIDs(maxSendCount int) ([]string, error) {
2020-12-15 14:43:41 +00:00
ids := []string{}
rows, err := db.db.Query(`
SELECT
id
FROM
raw_messages
WHERE
(message_type IN (?, ?) OR resend_automatically) AND sent = ? AND send_count <= ?`,
protobuf.ApplicationMetadataMessage_CHAT_MESSAGE,
protobuf.ApplicationMetadataMessage_EMOJI_REACTION,
false,
maxSendCount)
2020-12-15 14:43:41 +00:00
if err != nil {
return ids, err
}
defer rows.Close()
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return ids, err
}
ids = append(ids, id)
}
return ids, nil
}
func (db sqlitePersistence) SaveContact(contact *Contact, tx *sql.Tx) (err error) {
if tx == nil {
tx, err = db.db.BeginTx(context.Background(), &sql.TxOptions{})
if err != nil {
return
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
// don't shadow original error
_ = tx.Rollback()
}()
}
// Insert record
2021-03-24 08:04:03 +00:00
// NOTE: name, photo and tribute_to_talk are not used anymore, but it's not nullable
2021-01-11 10:32:51 +00:00
// Removing it requires copying over the table which might be expensive
// when there are many contacts, so best avoiding it
stmt, err := tx.Prepare(`
INSERT INTO contacts(
id,
address,
alias,
2022-02-17 15:13:10 +00:00
display_name,
identicon,
last_updated,
last_updated_locally,
local_nickname,
contact_request_state,
2023-01-20 14:28:30 +00:00
contact_request_local_clock,
contact_request_remote_state,
contact_request_remote_clock,
2021-03-24 08:04:03 +00:00
blocked,
removed,
verification_status,
2021-03-24 08:04:03 +00:00
name,
2021-01-11 10:32:51 +00:00
photo,
tribute_to_talk
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`)
if err != nil {
return
}
defer stmt.Close()
_, err = stmt.Exec(
contact.ID,
contact.Address,
contact.Alias,
2022-02-17 15:13:10 +00:00
contact.DisplayName,
contact.Identicon,
contact.LastUpdated,
contact.LastUpdatedLocally,
2020-08-20 14:06:38 +00:00
contact.LocalNickname,
2023-01-20 14:28:30 +00:00
contact.ContactRequestLocalState,
contact.ContactRequestLocalClock,
contact.ContactRequestRemoteState,
contact.ContactRequestRemoteClock,
2021-03-24 08:04:03 +00:00
contact.Blocked,
contact.Removed,
contact.VerificationStatus,
2021-03-24 08:04:03 +00:00
//TODO we need to drop these columns
"",
"",
"",
)
return
}
func (db sqlitePersistence) SaveTransactionToValidate(transaction *TransactionToValidate) error {
compressedKey := crypto.CompressPubkey(transaction.From)
_, err := db.db.Exec(`INSERT INTO messenger_transactions_to_validate(
command_id,
2021-03-24 08:04:03 +00:00
message_id,
transaction_hash,
retry_count,
first_seen,
public_key,
signature,
to_validate)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
transaction.CommandID,
transaction.MessageID,
transaction.TransactionHash,
transaction.RetryCount,
transaction.FirstSeen,
compressedKey,
transaction.Signature,
transaction.Validate,
)
return err
}
func (db sqlitePersistence) UpdateTransactionToValidate(transaction *TransactionToValidate) error {
_, err := db.db.Exec(`UPDATE messenger_transactions_to_validate
SET retry_count = ?, to_validate = ?
WHERE transaction_hash = ?`,
transaction.RetryCount,
transaction.Validate,
transaction.TransactionHash,
)
return err
}
func (db sqlitePersistence) TransactionsToValidate() ([]*TransactionToValidate, error) {
var transactions []*TransactionToValidate
rows, err := db.db.Query(`
SELECT
command_id,
message_id,
transaction_hash,
retry_count,
first_seen,
public_key,
signature,
to_validate
FROM messenger_transactions_to_validate
WHERE to_validate = 1;
`)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
var t TransactionToValidate
var pkBytes []byte
err = rows.Scan(
&t.CommandID,
&t.MessageID,
&t.TransactionHash,
&t.RetryCount,
&t.FirstSeen,
&pkBytes,
&t.Signature,
&t.Validate,
)
if err != nil {
return nil, err
}
publicKey, err := crypto.DecompressPubkey(pkBytes)
if err != nil {
return nil, err
}
t.From = publicKey
transactions = append(transactions, &t)
}
return transactions, nil
}
2020-12-16 18:28:34 +00:00
func (db sqlitePersistence) GetWhenChatIdentityLastPublished(chatID string) (t int64, hash []byte, err error) {
2020-12-10 10:12:51 +00:00
rows, err := db.db.Query("SELECT clock_value, hash FROM chat_identity_last_published WHERE chat_id = ?", chatID)
if err != nil {
2020-12-16 18:28:34 +00:00
return t, nil, err
}
defer func() {
err = rows.Close()
}()
for rows.Next() {
2020-12-16 18:28:34 +00:00
err = rows.Scan(&t, &hash)
if err != nil {
2020-12-16 18:28:34 +00:00
return t, nil, err
}
}
return t, hash, nil
}
func (db sqlitePersistence) SaveWhenChatIdentityLastPublished(chatID string, hash []byte) (err error) {
tx, err := db.db.BeginTx(context.Background(), &sql.TxOptions{})
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
// don't shadow original error
_ = tx.Rollback()
}()
2020-12-10 10:12:51 +00:00
stmt, err := tx.Prepare("INSERT INTO chat_identity_last_published (chat_id, clock_value, hash) VALUES (?, ?, ?)")
if err != nil {
return err
}
defer stmt.Close()
2020-12-10 10:12:51 +00:00
_, err = stmt.Exec(chatID, time.Now().Unix(), hash)
if err != nil {
return err
}
return nil
}
2021-02-17 23:14:48 +00:00
func (db sqlitePersistence) ResetWhenChatIdentityLastPublished(chatID string) (err error) {
tx, err := db.db.BeginTx(context.Background(), &sql.TxOptions{})
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
// don't shadow original error
_ = tx.Rollback()
}()
stmt, err := tx.Prepare("INSERT INTO chat_identity_last_published (chat_id, clock_value, hash) VALUES (?, ?, ?)")
if err != nil {
return err
}
defer stmt.Close()
_, err = stmt.Exec(chatID, 0, []byte("."))
if err != nil {
return err
}
return nil
}
func (db sqlitePersistence) InsertStatusUpdate(userStatus UserStatus) error {
_, err := db.db.Exec(`INSERT INTO status_updates(
public_key,
status_type,
clock,
custom_text)
VALUES (?, ?, ?, ?)`,
userStatus.PublicKey,
userStatus.StatusType,
userStatus.Clock,
userStatus.CustomText,
)
return err
}
func (db sqlitePersistence) CleanOlderStatusUpdates() error {
now := time.Now()
2021-10-28 15:21:28 +00:00
twoWeeksAgo := now.Add(time.Duration(-1*HoursInTwoWeeks) * time.Hour)
_, err := db.db.Exec(`DELETE FROM status_updates WHERE clock < ?`,
2021-10-28 15:21:28 +00:00
uint64(twoWeeksAgo.Unix()),
)
return err
}
func (db sqlitePersistence) StatusUpdates() (statusUpdates []UserStatus, err error) {
rows, err := db.db.Query(`
SELECT
public_key,
status_type,
clock,
custom_text
FROM status_updates
`)
if err != nil {
return
}
defer rows.Close()
for rows.Next() {
var userStatus UserStatus
err = rows.Scan(
&userStatus.PublicKey,
&userStatus.StatusType,
&userStatus.Clock,
&userStatus.CustomText,
)
if err != nil {
return
}
statusUpdates = append(statusUpdates, userStatus)
}
return
}
2023-01-05 16:11:57 +00:00
func (db sqlitePersistence) DeleteSwitcherCard(cardID string) error {
_, err := db.db.Exec("DELETE from switcher_cards WHERE card_id = ?", cardID)
return err
}
func (db sqlitePersistence) UpsertSwitcherCard(switcherCard SwitcherCard) error {
_, err := db.db.Exec(`INSERT INTO switcher_cards(
card_id,
type,
clock,
screen_id)
VALUES (?, ?, ?, ?)`,
switcherCard.CardID,
switcherCard.Type,
switcherCard.Clock,
switcherCard.ScreenID,
)
return err
}
func (db sqlitePersistence) SwitcherCards() (switcherCards []SwitcherCard, err error) {
rows, err := db.db.Query(`
SELECT
card_id,
type,
clock,
screen_id
FROM switcher_cards
`)
if err != nil {
return
}
defer rows.Close()
for rows.Next() {
var switcherCard SwitcherCard
err = rows.Scan(
&switcherCard.CardID,
&switcherCard.Type,
&switcherCard.Clock,
&switcherCard.ScreenID,
)
if err != nil {
return
}
switcherCards = append(switcherCards, switcherCard)
}
return
}
func (db sqlitePersistence) NextHigherClockValueOfAutomaticStatusUpdates(clock uint64) (uint64, error) {
var nextClock uint64
err := db.db.QueryRow(`
SELECT clock
FROM status_updates
WHERE clock > ? AND status_type = ?
LIMIT 1
`, clock, protobuf.StatusUpdate_AUTOMATIC).Scan(&nextClock)
switch err {
case sql.ErrNoRows:
return 0, common.ErrRecordNotFound
case nil:
return nextClock, nil
default:
return 0, err
}
}
func (db sqlitePersistence) DeactivatedAutomaticStatusUpdates(fromClock uint64, tillClock uint64) (statusUpdates []UserStatus, err error) {
rows, err := db.db.Query(`
SELECT
public_key,
?,
clock + 1,
custom_text
FROM status_updates
WHERE clock > ? AND clock <= ? AND status_type = ?
`, protobuf.StatusUpdate_INACTIVE, fromClock, tillClock, protobuf.StatusUpdate_AUTOMATIC)
if err != nil {
return
}
defer rows.Close()
for rows.Next() {
var userStatus UserStatus
err = rows.Scan(
&userStatus.PublicKey,
&userStatus.StatusType,
&userStatus.Clock,
&userStatus.CustomText,
)
if err != nil {
return
}
statusUpdates = append(statusUpdates, userStatus)
}
return
}
func (db *sqlitePersistence) AddBookmark(bookmark browsers.Bookmark) (browsers.Bookmark, error) {
tx, err := db.db.Begin()
if err != nil {
return bookmark, err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
insert, err := tx.Prepare("INSERT OR REPLACE INTO bookmarks (url, name, image_url, removed, clock) VALUES (?, ?, ?, ?, ?)")
if err != nil {
return bookmark, err
}
// Get the right icon
finder := besticon.IconFinder{}
icons, iconError := finder.FetchIcons(bookmark.URL)
if iconError == nil && len(icons) > 0 {
2023-01-13 17:12:46 +00:00
icon := finder.IconInSizeRange(besticon.SizeRange{Min: 48, Perfect: 48, Max: 100})
if icon != nil {
bookmark.ImageURL = icon.URL
} else {
bookmark.ImageURL = icons[0].URL
}
} else {
log.Error("error getting the bookmark icon", "iconError", iconError)
}
_, err = insert.Exec(bookmark.URL, bookmark.Name, bookmark.ImageURL, bookmark.Removed, bookmark.Clock)
return bookmark, err
}
func (db *sqlitePersistence) AddBrowser(browser browsers.Browser) (err error) {
tx, err := db.db.Begin()
if err != nil {
return
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
insert, err := tx.Prepare("INSERT OR REPLACE INTO browsers(id, name, timestamp, dapp, historyIndex) VALUES(?, ?, ?, ?, ?)")
if err != nil {
return
}
_, err = insert.Exec(browser.ID, browser.Name, browser.Timestamp, browser.Dapp, browser.HistoryIndex)
insert.Close()
if err != nil {
return
}
if len(browser.History) == 0 {
return
}
bhInsert, err := tx.Prepare("INSERT INTO browsers_history(browser_id, history) VALUES(?, ?)")
if err != nil {
return
}
defer bhInsert.Close()
for _, history := range browser.History {
_, err = bhInsert.Exec(browser.ID, history)
if err != nil {
return
}
}
return
}
func (db *sqlitePersistence) InsertBrowser(browser browsers.Browser) (err error) {
tx, err := db.db.Begin()
if err != nil {
return
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
bInsert, err := tx.Prepare("INSERT OR REPLACE INTO browsers(id, name, timestamp, dapp, historyIndex) VALUES(?, ?, ?, ?, ?)")
if err != nil {
return
}
_, err = bInsert.Exec(browser.ID, browser.Name, browser.Timestamp, browser.Dapp, browser.HistoryIndex)
bInsert.Close()
if err != nil {
return
}
if len(browser.History) == 0 {
return
}
bhInsert, err := tx.Prepare("INSERT INTO browsers_history(browser_id, history) VALUES(?, ?)")
if err != nil {
return
}
defer bhInsert.Close()
for _, history := range browser.History {
_, err = bhInsert.Exec(browser.ID, history)
if err != nil {
return
}
}
return
}
func (db *sqlitePersistence) RemoveBookmark(url string, deletedAt uint64) error {
tx, err := db.db.Begin()
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
_, err = tx.Exec(`UPDATE bookmarks SET removed = 1, deleted_at = ? WHERE url = ?`, deletedAt, url)
return err
}
func (db *sqlitePersistence) GetBrowsers() (rst []*browsers.Browser, err error) {
tx, err := db.db.Begin()
if err != nil {
return
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
// FULL and RIGHT joins are not supported
bRows, err := tx.Query("SELECT id, name, timestamp, dapp, historyIndex FROM browsers ORDER BY timestamp DESC")
if err != nil {
return
}
defer bRows.Close()
browsersArr := map[string]*browsers.Browser{}
for bRows.Next() {
browser := browsers.Browser{}
err = bRows.Scan(&browser.ID, &browser.Name, &browser.Timestamp, &browser.Dapp, &browser.HistoryIndex)
if err != nil {
return nil, err
}
browsersArr[browser.ID] = &browser
rst = append(rst, &browser)
}
bhRows, err := tx.Query("SELECT browser_id, history from browsers_history")
if err != nil {
return
}
defer bhRows.Close()
var (
id string
history string
)
for bhRows.Next() {
err = bhRows.Scan(&id, &history)
if err != nil {
return
}
browsersArr[id].History = append(browsersArr[id].History, history)
}
return rst, nil
}
func (db *sqlitePersistence) DeleteBrowser(id string) error {
_, err := db.db.Exec("DELETE from browsers WHERE id = ?", id)
return err
}
func (db *sqlitePersistence) GetBookmarkByURL(url string) (*browsers.Bookmark, error) {
bookmark := browsers.Bookmark{}
err := db.db.QueryRow(`SELECT url, name, image_url, removed, clock, deleted_at FROM bookmarks WHERE url = ?`, url).Scan(&bookmark.URL, &bookmark.Name, &bookmark.ImageURL, &bookmark.Removed, &bookmark.Clock, &bookmark.DeletedAt)
if err != nil {
return nil, err
}
return &bookmark, nil
}
func (db *sqlitePersistence) UpdateBookmark(oldURL string, bookmark browsers.Bookmark) error {
tx, err := db.db.Begin()
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
insert, err := tx.Prepare("UPDATE bookmarks SET url = ?, name = ?, image_url = ?, removed = ?, clock = ?, deleted_at = ? WHERE url = ?")
if err != nil {
return err
}
_, err = insert.Exec(bookmark.URL, bookmark.Name, bookmark.ImageURL, bookmark.Removed, bookmark.Clock, bookmark.DeletedAt, oldURL)
return err
}
func (db *sqlitePersistence) DeleteSoftRemovedBookmarks(threshold uint64) error {
tx, err := db.db.Begin()
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
_, err = tx.Exec(`DELETE from bookmarks WHERE removed = 1 AND deleted_at < ?`, threshold)
return err
}
func (db *sqlitePersistence) InsertWalletConnectSession(session *WalletConnectSession) error {
tx, err := db.db.Begin()
if err != nil {
return err
}
defer func() {
if err == nil {
err = tx.Commit()
return
}
_ = tx.Rollback()
}()
sessionInsertPreparedStatement, err := tx.Prepare("INSERT OR REPLACE INTO wallet_connect_v1_sessions(peer_id, dapp_name, dapp_url, info) VALUES(?, ?, ?, ?)")
if err != nil {
return err
}
defer sessionInsertPreparedStatement.Close()
_, err = sessionInsertPreparedStatement.Exec(session.PeerID, session.DAppName, session.DAppURL, session.Info)
return err
}
func (db *sqlitePersistence) GetWalletConnectSession() ([]WalletConnectSession, error) {
var sessions []WalletConnectSession
rows, err := db.db.Query("SELECT peer_id, dapp_name, dapp_url, info FROM wallet_connect_v1_sessions ORDER BY dapp_name")
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
session := WalletConnectSession{}
err = rows.Scan(&session.PeerID, &session.DAppName, &session.DAppURL, &session.Info)
if err != nil {
return nil, err
}
sessions = append(sessions, session)
}
return sessions, nil
}
func (db *sqlitePersistence) DeleteWalletConnectSession(peerID string) error {
deleteStatement, err := db.db.Prepare("DELETE FROM wallet_connect_v1_sessions where peer_id=?")
if err != nil {
return err
}
defer deleteStatement.Close()
_, err = deleteStatement.Exec(peerID)
return err
}