watsonb8/groupme
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

super basic

Browse Source
This commit is contained in:
Karmanyaah Malhotra
2021-02-21 00:58:50 -05:00
parent eafc18099d
commit 7cb9983da8
17 changed files with 965 additions and 926 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
database/database.go
View File

@ -17,6 +17,8 @@
package database
import (
"strings"
_ "github.com/lib/pq"
_ "github.com/mattn/go-sqlite3"
@ -26,6 +28,7 @@ import (
"gorm.io/driver/postgres"
"gorm.io/driver/sqlite"
"gorm.io/gorm"
"gorm.io/gorm/schema"
)
type Database struct {
@ -52,6 +55,9 @@ func New(dbType string, uri string, baseLog log.Logger) (*Database, error) {
print("no")
gdb, err := gorm.Open(conn, &gorm.Config{
// Logger: baseLog,
NamingStrategy: schema.NamingStrategy{
NameReplacer: strings.NewReplacer("JID", "Jid", "MXID", "Mxid"),
},
})
if err != nil {
panic("failed to connect database")
@ -81,6 +87,7 @@ func New(dbType string, uri string, baseLog log.Logger) (*Database, error) {
}
func (db *Database) Init() error {
println("actual upgrade")
err := db.AutoMigrate(&Portal{})
if err != nil {
return err
@ -104,6 +111,14 @@ func (db *Database) Init() error {
return err
}
err = db.AutoMigrate(&User{})
if err != nil {
return err
}
err = db.AutoMigrate(&UserPortal{})
if err != nil {
return err
}
return upgrades.Run(db.log.Sub("Upgrade"), db.dialect, db.DB)
}

24
database/message.go
View File

@ -46,8 +46,8 @@ func (mq *MessageQuery) GetAll(chat PortalKey) (messages []*Message) {
func (mq *MessageQuery) GetByJID(chat PortalKey, jid types.WhatsAppMessageID) *Message {
var message Message
ans := mq.db.Where("chat_jid = ? AND chat_receiver = ? AND jid = ?", chat.JID, chat.Receiver, jid).Take(&message)
if ans.Error != nil {
ans := mq.db.Where("chat_jid = ? AND chat_receiver = ? AND jid = ?", chat.JID, chat.Receiver, jid).Limit(1).Find(&message)
if ans.Error != nil || ans.RowsAffected == 0 {
return nil
}
return &message
@ -55,8 +55,8 @@ func (mq *MessageQuery) GetByJID(chat PortalKey, jid types.WhatsAppMessageID) *M
func (mq *MessageQuery) GetByMXID(mxid id.EventID) *Message {
var message Message
ans := mq.db.Where("mxid = ?", mxid).Take(&message)
if ans.Error != nil {
ans := mq.db.Where("mxid = ?", mxid).Limit(1).Find(&message)
if ans.Error != nil || ans.RowsAffected == 0 {
return nil
}
return &message
@ -64,8 +64,8 @@ func (mq *MessageQuery) GetByMXID(mxid id.EventID) *Message {
func (mq *MessageQuery) GetLastInChat(chat PortalKey) *Message {
var message Message
ans := mq.db.Where("chat_jid = ? AND chat_receiver = ?", chat.JID, chat.Receiver).Order("timestamp desc").First(&message)
if ans.Error != nil {
ans := mq.db.Where("chat_jid = ? AND chat_receiver = ?", chat.JID, chat.Receiver).Order("timestamp desc").Limit(1).Find(&message)
if ans.Error != nil || ans.RowsAffected == 0 {
return nil
}
return &message
@ -76,12 +76,12 @@ type Message struct {
db *Database
log log.Logger
Chat PortalKey `gorm:"primaryKey;embedded;embeddedPrefix:chat_"`
JID types.WhatsAppMessageID `gorm:"primaryKey"`
MXID id.EventID `gorm:"unique;notNull"`
Sender types.GroupMeID `gorm:"notNull"`
Timestamp uint64 `gorm:"notNull;default:0"`
Content *groupme.Message `gorm:"type:TEXT;notNull"`
Chat PortalKey `gorm:"primaryKey;embedded;embeddedPrefix:chat_"`
JID types.GroupMeID `gorm:"primaryKey"`
MXID id.EventID `gorm:"unique;notNull"`
Sender types.GroupMeID `gorm:"notNull"`
Timestamp uint64 `gorm:"notNull;default:0"`
Content *groupme.Message `gorm:"type:TEXT;notNull"`
// Portal Portal `gorm:"foreignKey:JID;"` //`gorm:"foreignKey:Chat.Receiver,Chat.JID;references:jid,receiver;constraint:onDelete:CASCADE;"`TODO
}

17
database/portal.go
View File

@ -73,7 +73,7 @@ func (pq *PortalQuery) GetAll() []*Portal {
}
func (pq *PortalQuery) GetByJID(key PortalKey) *Portal {
return pq.get(pq.db.DB.Where("jit = ? AND receiver = ?", key.JID, key.Receiver))
return pq.get(pq.db.DB.Where("jid = ? AND receiver = ?", key.JID, key.Receiver))
}
@ -97,16 +97,23 @@ func (pq *PortalQuery) getAll(db *gorm.DB) (portals []*Portal) {
if ans.Error != nil || len(portals) == 0 {
return nil
}
for _, i := range portals {
i.db = pq.db
i.log = pq.log
}
return
}
func (pq *PortalQuery) get(db *gorm.DB) *Portal {
var portal Portal
ans := db.Take(&portal)
if ans.Error != nil {
ans := db.Limit(1).Find(&portal)
if ans.Error != nil || db.RowsAffected == 0 {
return nil
}
portal.db = pq.db
portal.log = pq.log
return &portal
}
@ -155,8 +162,7 @@ func (portal *Portal) Insert() {
}
func (portal *Portal) Update() {
ans := portal.db.Model(&portal).Updates(portal)
ans := portal.db.Where("jid = ? AND receiver = ?", portal.Key.JID, portal.Key.Receiver).Save(&portal)
print("check .model vs not")
if ans.Error != nil {
@ -172,6 +178,7 @@ func (portal *Portal) Delete() {
}
func (portal *Portal) GetUserIDs() []id.UserID {
println("HI AAAAAAAAAAAAAAAAAAAa")
rows, err := portal.db.Raw(`SELECT "user".mxid FROM "user", user_portal
WHERE "user".jid=user_portal.user_jid
AND user_portal.portal_jid=$1

10
database/puppet.go
View File

@ -53,8 +53,8 @@ func (pq *PuppetQuery) GetAll() (puppets []*Puppet) {
func (pq *PuppetQuery) Get(jid types.GroupMeID) *Puppet {
puppet := Puppet{}
ans := pq.db.Where("jid = ?", jid).Take(puppet)
if ans.Error != nil {
ans := pq.db.Where("jid = ?", jid).Limit(1).Find(&puppet)
if ans.Error != nil || ans.RowsAffected == 0 {
return nil
}
return &puppet
@ -62,8 +62,8 @@ func (pq *PuppetQuery) Get(jid types.GroupMeID) *Puppet {
func (pq *PuppetQuery) GetByCustomMXID(mxid id.UserID) *Puppet {
puppet := Puppet{}
ans := pq.db.Where("custom_mxid = ?", mxid).Take(puppet)
if ans.Error != nil {
ans := pq.db.Where("custom_mxid = ?", mxid).Limit(1).Find(&puppet)
if ans.Error != nil || ans.RowsAffected == 0 {
return nil
}
return &puppet
@ -93,7 +93,7 @@ type Puppet struct {
Displayname string
NameQuality int8
CustomMXID id.UserID
CustomMXID id.UserID `gorm:"column:custom_mxid;"`
AccessToken string
NextBatch string
EnablePresence bool `gorm:"notNull;default:true"`

13
database/statestore.go
View File

@ -55,7 +55,8 @@ func NewSQLStateStore(db *Database) *SQLStateStore {
func (store *SQLStateStore) IsRegistered(userID id.UserID) bool {
v := mxRegistered{UserID: userID.String()}
ans := store.db.First(&v)
var count int64
ans := store.db.Model(&mxRegistered{}).Where(&v).Count(&count)
if errors.Is(ans.Error, gorm.ErrRecordNotFound) {
return false
@ -63,7 +64,7 @@ func (store *SQLStateStore) IsRegistered(userID id.UserID) bool {
if ans.Error != nil {
store.log.Warnfln("Failed to scan registration existence for %s: %v", userID, ans.Error)
}
return true
return count >= 1
}
func (store *SQLStateStore) MarkRegistered(userID id.UserID) {
@ -113,7 +114,7 @@ func (store *SQLStateStore) GetRoomMembers(roomID id.RoomID) map[id.UserID]*even
func (store *SQLStateStore) GetMembership(roomID id.RoomID, userID id.UserID) event.Membership {
var user mxUserProfile
ans := store.db.Where("room_id = ? AND user_id = ?", roomID, userID).Take(&user)
ans := store.db.Where("room_id = ? AND user_id = ?", roomID, userID).Limit(1).Find(&user)
membership := event.MembershipLeave
if ans.Error != nil && ans.Error != gorm.ErrRecordNotFound {
store.log.Warnfln("Failed to scan membership of %s in %s: %v", userID, roomID, ans.Error)
@ -197,8 +198,8 @@ func (store *SQLStateStore) SetMembership(roomID id.RoomID, userID id.UserID, me
print("weird thing 2 502650285")
print(user.Membership)
ans := store.db.Select("roomID", "userID", "membership").Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "roomID"}, {Name: "userID"}},
ans := store.db.Debug().Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "room_id"}, {Name: "user_id"}},
DoUpdates: clause.AssignmentColumns([]string{"membership"}),
}).Create(&user)
@ -217,7 +218,7 @@ func (store *SQLStateStore) SetMember(roomID id.RoomID, userID id.UserID, member
AvatarURL: string(member.AvatarURL),
}
ans := store.db.Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "roomID"}, {Name: "userID"}},
Columns: []clause.Column{{Name: "room_id"}, {Name: "user_id"}},
DoUpdates: clause.AssignmentColumns([]string{"membership"}),
}).Create(&user)

293
database/user.go
View File

@ -17,15 +17,12 @@
package database
import (
"database/sql"
"strings"
"github.com/Rhymen/go-whatsapp"
"time"
log "maunium.net/go/maulogger/v2"
"maunium.net/go/mautrix-whatsapp/types"
whatsappExt "maunium.net/go/mautrix-whatsapp/whatsapp-ext"
"maunium.net/go/mautrix/id"
)
@ -42,72 +39,77 @@ func (uq *UserQuery) New() *User {
}
func (uq *UserQuery) GetAll() (users []*User) {
// rows, err := uq.db.Query(`SELECT mxid, jid, management_room, last_connection, client_id, client_token, server_token, enc_key, mac_key FROM "user"`)
// if err != nil || rows == nil {
// return nil
// }
// defer rows.Close()
// for rows.Next() {
// users = append(users, uq.New().Scan(rows))
// }
ans := uq.db.Find(&users)
if ans.Error != nil || len(users) == 0 {
return nil
}
for _, i := range users {
i.db = uq.db
i.log = uq.log
}
return
}
func (uq *UserQuery) GetByMXID(userID id.UserID) *User {
// row := uq.db.QueryRow(`SELECT mxid, jid, management_room, last_connection, client_id, client_token, server_token, enc_key, mac_key FROM "user" WHERE mxid=$1`, userID)
// if row == nil {
// return nil
// }
// return uq.New().Scan(row)
return nil
var user User
ans := uq.db.Where("mxid = ?", userID).Take(&user)
user.db = uq.db
user.log = uq.log
if ans.Error != nil {
return nil
}
return &user
}
func (uq *UserQuery) GetByJID(userID types.GroupMeID) *User {
// row := uq.db.QueryRow(`SELECT mxid, jid, management_room, last_connection, client_id, client_token, server_token, enc_key, mac_key FROM "user" WHERE jid=$1`, stripSuffix(userID))
// if row == nil {
// return nil
// }
// return uq.New().Scan(row)
return nil
var user User
ans := uq.db.Where("jid = ?", userID).Limit(1).Find(&user)
if ans.Error != nil || ans.RowsAffected == 0 {
return nil
}
user.db = uq.db
user.log = uq.log
return &user
}
type User struct {
db *Database
log log.Logger
MXID id.UserID
JID types.GroupMeID
Token types.AuthToken
MXID id.UserID `gorm:"primaryKey"`
JID types.GroupMeID `gorm:"unique"`
Token types.AuthToken
ManagementRoom id.RoomID
LastConnection uint64
LastConnection uint64 `gorm:"notNull;default:0"`
}
func (user *User) Scan(row Scannable) *User {
var jid, clientID, clientToken, serverToken sql.NullString
var encKey, macKey []byte
err := row.Scan(&user.MXID, &jid, &user.ManagementRoom, &user.LastConnection, &clientID, &clientToken, &serverToken, &encKey, &macKey)
if err != nil {
if err != sql.ErrNoRows {
user.log.Errorln("Database scan failed:", err)
}
return nil
}
if len(jid.String) > 0 && len(clientID.String) > 0 {
user.JID = jid.String + whatsappExt.NewUserSuffix
// user.Session = &whatsapp.Session{
// ClientId: clientID.String,
// ClientToken: clientToken.String,
// ServerToken: serverToken.String,
// EncKey: encKey,
// MacKey: macKey,
// Wid: jid.String + whatsappExt.OldUserSuffix,
// }
}// else {
// user.Session = nil
// }
return user
}
//func (user *User) Scan(row Scannable) *User {
// var jid, clientID, clientToken, serverToken sql.NullString
// var encKey, macKey []byte
// err := row.Scan(&user.MXID, &jid, &user.ManagementRoom, &user.LastConnection, &clientID, &clientToken, &serverToken, &encKey, &macKey)
// if err != nil {
// if err != sql.ErrNoRows {
// user.log.Errorln("Database scan failed:", err)
// }
// return nil
// }
// if len(jid.String) > 0 && len(clientID.String) > 0 {
// user.JID = jid.String + whatsappExt.NewUserSuffix
// // user.Session = &whatsapp.Session{
// // ClientId: clientID.String,
// // ClientToken: clientToken.String,
// // ServerToken: serverToken.String,
// // EncKey: encKey,
// // MacKey: macKey,
// // Wid: jid.String + whatsappExt.OldUserSuffix,
// // }
// } // else {
// // user.Session = nil
// // }
// return user
//}
func stripSuffix(jid types.GroupMeID) string {
if len(jid) == 0 {
@ -130,42 +132,30 @@ func (user *User) jidPtr() *string {
return nil
}
func (user *User) sessionUnptr() (sess whatsapp.Session) {
// if user.Session != nil {
// sess = *user.Session
// }
return
}
//func (user *User) sessionUnptr() (sess whatsapp.Session) {
// // if user.Session != nil {
// // sess = *user.Session
// // }
// return
//}
func (user *User) Insert() {
// sess := user.sessionUnptr()
// _, err := user.db.Exec(`INSERT INTO "user" (mxid, jid, management_room, last_connection, client_id, client_token, server_token, enc_key, mac_key) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
// user.MXID, user.jidPtr(),
// user.ManagementRoom, user.LastConnection,
// sess.ClientId, sess.ClientToken, sess.ServerToken, sess.EncKey, sess.MacKey)
// if err != nil {
// user.log.Warnfln("Failed to insert %s: %v", user.MXID, err)
// }
ans := user.db.Create(&user)
if ans.Error != nil {
user.log.Warnfln("Failed to insert %s: %v", user.MXID, ans.Error)
}
}
func (user *User) UpdateLastConnection() {
// user.LastConnection = uint64(time.Now().Unix())
// _, err := user.db.Exec(`UPDATE "user" SET last_connection=$1 WHERE mxid=$2`,
// user.LastConnection, user.MXID)
// if err != nil {
// user.log.Warnfln("Failed to update last connection ts: %v", err)
// }
user.LastConnection = uint64(time.Now().Unix())
user.Update()
}
func (user *User) Update() {
// sess := user.sessionUnptr()
// _, err := user.db.Exec(`UPDATE "user" SET jid=$1, management_room=$2, last_connection=$3, client_id=$4, client_token=$5, server_token=$6, enc_key=$7, mac_key=$8 WHERE mxid=$9`,
// user.jidPtr(), user.ManagementRoom, user.LastConnection,
// sess.ClientId, sess.ClientToken, sess.ServerToken, sess.EncKey, sess.MacKey,
// user.MXID)
// if err != nil {
// user.log.Warnfln("Failed to update %s: %v", user.MXID, err)
// }
ans := user.db.Save(&user)
if ans.Error != nil {
user.log.Warnfln("Failed to update last connection ts: %v", ans.Error)
}
}
type PortalKeyWithMeta struct {
@ -173,82 +163,85 @@ type PortalKeyWithMeta struct {
InCommunity bool
}
type UserPortal struct {
UserJID types.GroupMeID `gorm:"primaryKey;"`
PortalJID types.GroupMeID `gorm:"primaryKey;"`
PortalReceiver types.GroupMeID `gorm:"primaryKey;"`
InCommunity bool `gorm:"notNull;default:false;"`
User User `gorm:"foreignKey:UserJID;references:jid;constraint:OnDelete:CASCADE;"`
Portal Portal `gorm:"foreignKey:PortalJID,PortalReceiver;references:JID,Receiver;constraint:OnDelete:CASCADE;"`
}
func (user *User) SetPortalKeys(newKeys []PortalKeyWithMeta) error {
// tx, err := user.db.Begin()
// if err != nil {
// return err
// }
// _, err = tx.Exec("DELETE FROM user_portal WHERE user_jid=$1", user.jidPtr())
// if err != nil {
// _ = tx.Rollback()
// return err
// }
// valueStrings := make([]string, len(newKeys))
// values := make([]interface{}, len(newKeys)*4)
// for i, key := range newKeys {
// pos := i * 4
// valueStrings[i] = fmt.Sprintf("($%d, $%d, $%d, $%d)", pos+1, pos+2, pos+3, pos+4)
// values[pos] = user.jidPtr()
// values[pos+1] = key.JID
// values[pos+2] = key.Receiver
// values[pos+3] = key.InCommunity
// }
// query := fmt.Sprintf("INSERT INTO user_portal (user_jid, portal_jid, portal_receiver, in_community) VALUES %s",
// strings.Join(valueStrings, ", "))
// _, err = tx.Exec(query, values...)
// if err != nil {
// _ = tx.Rollback()
// return err
// }
// return tx.Commit()
return nil
tx := user.db.Begin()
ans := tx.Where("user_jid = ?", *user.jidPtr()).Delete(&UserPortal{})
print("make sure all are deletede")
if ans.Error != nil {
_ = tx.Rollback()
return ans.Error
}
for _, key := range newKeys {
ans = tx.Create(&UserPortal{
UserJID: *user.jidPtr(),
PortalJID: key.JID,
PortalReceiver: key.Receiver,
InCommunity: key.InCommunity,
})
if ans.Error != nil {
_ = tx.Rollback()
return ans.Error
}
}
return tx.Commit().Error
}
func (user *User) IsInPortal(key PortalKey) bool {
// row := user.db.QueryRow(`SELECT EXISTS(SELECT 1 FROM user_portal WHERE user_jid=$1 AND portal_jid=$2 AND portal_receiver=$3)`, user.jidPtr(), &key.JID, &key.Receiver)
// var exists bool
// _ = row.Scan(&exists)
// return exists
return false
var count int64
user.db.Find(&UserPortal{
UserJID: *user.jidPtr(),
PortalJID: key.JID,
PortalReceiver: key.Receiver,
}).Count(&count) //TODO: efficient
return count > 0
}
func (user *User) GetPortalKeys() []PortalKey {
// rows, err := user.db.Query(`SELECT portal_jid, portal_receiver FROM user_portal WHERE user_jid=$1`, user.jidPtr())
// if err != nil {
// user.log.Warnln("Failed to get user portal keys:", err)
// return nil
// }
// var keys []PortalKey
// for rows.Next() {
// var key PortalKey
// err = rows.Scan(&key.JID, &key.Receiver)
// if err != nil {
// user.log.Warnln("Failed to scan row:", err)
// continue
// }
// keys = append(keys, key)
// }
// return keys
return nil
var up []UserPortal
ans := user.db.Where("user_jid = ?", *user.jidPtr()).Find(&up)
if ans.Error != nil {
user.log.Warnln("Failed to get user portal keys:", ans.Error)
return nil
}
var keys []PortalKey
for _, i := range up {
key := PortalKey{
JID: i.UserJID,
Receiver: i.PortalReceiver,
}
keys = append(keys, key)
}
return keys
}
func (user *User) GetInCommunityMap() map[PortalKey]bool {
// rows, err := user.db.Query(`SELECT portal_jid, portal_receiver, in_community FROM user_portal WHERE user_jid=$1`, user.jidPtr())
// if err != nil {
// user.log.Warnln("Failed to get user portal keys:", err)
// return nil
// }
// keys := make(map[PortalKey]bool)
// for rows.Next() {
// var key PortalKey
// var inCommunity bool
// err = rows.Scan(&key.JID, &key.Receiver, &inCommunity)
// if err != nil {
// user.log.Warnln("Failed to scan row:", err)
// continue
// }
// keys[key] = inCommunity
// }
// return keys
return nil
var up []UserPortal
ans := user.db.Where("user_jid = ?", *user.jidPtr()).Find(&up)
if ans.Error != nil {
user.log.Warnln("Failed to get user portal keys:", ans.Error)
return nil
}
keys := make(map[PortalKey]bool)
for _, i := range up {
key := PortalKey{
JID: i.PortalJID,
Receiver: i.PortalReceiver,
}
keys[key] = i.InCommunity
}
return keys
}