diff --git a/storage-new/dbgen/activities.gen.go b/storage-new/dbgen/activities.gen.go index fadbb33..6c300d2 100644 --- a/storage-new/dbgen/activities.gen.go +++ b/storage-new/dbgen/activities.gen.go @@ -31,6 +31,7 @@ func newActivity(db *gorm.DB, opts ...gen.DOOption) activity { _activity.Type = field.NewString(tableName, "type") _activity.ObjectId = field.NewString(tableName, "object_id") _activity.ObjectType = field.NewUint32(tableName, "object_type") + _activity.RawData = field.NewBytes(tableName, "raw_data") _activity.fillFieldMap() @@ -45,6 +46,7 @@ type activity struct { Type field.String ObjectId field.String ObjectType field.Uint32 + RawData field.Bytes fieldMap map[string]field.Expr } @@ -65,6 +67,7 @@ func (a *activity) updateTableName(table string) *activity { a.Type = field.NewString(table, "type") a.ObjectId = field.NewString(table, "object_id") a.ObjectType = field.NewUint32(table, "object_type") + a.RawData = field.NewBytes(table, "raw_data") a.fillFieldMap() @@ -81,11 +84,12 @@ func (a *activity) GetFieldByName(fieldName string) (field.OrderExpr, bool) { } func (a *activity) fillFieldMap() { - a.fieldMap = make(map[string]field.Expr, 4) + a.fieldMap = make(map[string]field.Expr, 5) a.fieldMap["id"] = a.Id a.fieldMap["type"] = a.Type a.fieldMap["object_id"] = a.ObjectId a.fieldMap["object_type"] = a.ObjectType + a.fieldMap["raw_data"] = a.RawData } func (a activity) clone(db *gorm.DB) activity { diff --git a/storage-new/dbgen/gen.go b/storage-new/dbgen/gen.go index 58f7934..4994dfc 100644 --- a/storage-new/dbgen/gen.go +++ b/storage-new/dbgen/gen.go @@ -38,6 +38,7 @@ var ( RemoteServerMetadata *remoteServerMetadata Role *role ServerMetadata *serverMetadata + UnhandledMessage *unhandledMessage User *user UserAuthMethod *userAuthMethod UserInfoField *userInfoField @@ -72,6 +73,7 @@ func SetDefault(db *gorm.DB, opts ...gen.DOOption) { RemoteServerMetadata = &Q.RemoteServerMetadata Role = &Q.Role ServerMetadata = &Q.ServerMetadata + UnhandledMessage = &Q.UnhandledMessage User = &Q.User UserAuthMethod = &Q.UserAuthMethod UserInfoField = &Q.UserInfoField @@ -107,6 +109,7 @@ func Use(db *gorm.DB, opts ...gen.DOOption) *Query { RemoteServerMetadata: newRemoteServerMetadata(db, opts...), Role: newRole(db, opts...), ServerMetadata: newServerMetadata(db, opts...), + UnhandledMessage: newUnhandledMessage(db, opts...), User: newUser(db, opts...), UserAuthMethod: newUserAuthMethod(db, opts...), UserInfoField: newUserInfoField(db, opts...), @@ -143,6 +146,7 @@ type Query struct { RemoteServerMetadata remoteServerMetadata Role role ServerMetadata serverMetadata + UnhandledMessage unhandledMessage User user UserAuthMethod userAuthMethod UserInfoField userInfoField @@ -180,6 +184,7 @@ func (q *Query) clone(db *gorm.DB) *Query { RemoteServerMetadata: q.RemoteServerMetadata.clone(db), Role: q.Role.clone(db), ServerMetadata: q.ServerMetadata.clone(db), + UnhandledMessage: q.UnhandledMessage.clone(db), User: q.User.clone(db), UserAuthMethod: q.UserAuthMethod.clone(db), UserInfoField: q.UserInfoField.clone(db), @@ -224,6 +229,7 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query { RemoteServerMetadata: q.RemoteServerMetadata.replaceDB(db), Role: q.Role.replaceDB(db), ServerMetadata: q.ServerMetadata.replaceDB(db), + UnhandledMessage: q.UnhandledMessage.replaceDB(db), User: q.User.replaceDB(db), UserAuthMethod: q.UserAuthMethod.replaceDB(db), UserInfoField: q.UserInfoField.replaceDB(db), @@ -258,6 +264,7 @@ type queryCtx struct { RemoteServerMetadata IRemoteServerMetadataDo Role IRoleDo ServerMetadata IServerMetadataDo + UnhandledMessage IUnhandledMessageDo User IUserDo UserAuthMethod IUserAuthMethodDo UserInfoField IUserInfoFieldDo @@ -292,6 +299,7 @@ func (q *Query) WithContext(ctx context.Context) *queryCtx { RemoteServerMetadata: q.RemoteServerMetadata.WithContext(ctx), Role: q.Role.WithContext(ctx), ServerMetadata: q.ServerMetadata.WithContext(ctx), + UnhandledMessage: q.UnhandledMessage.WithContext(ctx), User: q.User.WithContext(ctx), UserAuthMethod: q.UserAuthMethod.WithContext(ctx), UserInfoField: q.UserInfoField.WithContext(ctx), diff --git a/storage-new/dbgen/notes.gen.go b/storage-new/dbgen/notes.gen.go index 946acbc..18fcc5e 100644 --- a/storage-new/dbgen/notes.gen.go +++ b/storage-new/dbgen/notes.gen.go @@ -40,6 +40,7 @@ func newNote(db *gorm.DB, opts ...gen.DOOption) note { _note.Quotes = field.NewField(tableName, "quotes") _note.AccessLevel = field.NewField(tableName, "access_level") _note.OriginId = field.NewUint(tableName, "origin_id") + _note.RawData = field.NewBytes(tableName, "raw_data") _note.AttachmentRelations = noteHasManyAttachmentRelations{ db: db.Session(&gorm.Session{}), @@ -580,6 +581,7 @@ type note struct { Quotes field.Field AccessLevel field.Field OriginId field.Uint + RawData field.Bytes AttachmentRelations noteHasManyAttachmentRelations EmoteRelations noteHasManyEmoteRelations @@ -621,6 +623,7 @@ func (n *note) updateTableName(table string) *note { n.Quotes = field.NewField(table, "quotes") n.AccessLevel = field.NewField(table, "access_level") n.OriginId = field.NewUint(table, "origin_id") + n.RawData = field.NewBytes(table, "raw_data") n.fillFieldMap() @@ -637,7 +640,7 @@ func (n *note) GetFieldByName(fieldName string) (field.OrderExpr, bool) { } func (n *note) fillFieldMap() { - n.fieldMap = make(map[string]field.Expr, 19) + n.fieldMap = make(map[string]field.Expr, 20) n.fieldMap["id"] = n.ID n.fieldMap["created_at"] = n.CreatedAt n.fieldMap["updated_at"] = n.UpdatedAt @@ -650,6 +653,7 @@ func (n *note) fillFieldMap() { n.fieldMap["quotes"] = n.Quotes n.fieldMap["access_level"] = n.AccessLevel n.fieldMap["origin_id"] = n.OriginId + n.fieldMap["raw_data"] = n.RawData } diff --git a/storage-new/dbgen/server_metadata.gen.go b/storage-new/dbgen/server_metadata.gen.go index 4863d5d..c46ba58 100644 --- a/storage-new/dbgen/server_metadata.gen.go +++ b/storage-new/dbgen/server_metadata.gen.go @@ -38,6 +38,7 @@ func newServerMetadata(db *gorm.DB, opts ...gen.DOOption) serverMetadata { _serverMetadata.LEIssuerCertificate = field.NewBytes(tableName, "le_issuer_certificate") _serverMetadata.LECSR = field.NewBytes(tableName, "lecsr") _serverMetadata.LELastUpdate = field.NewField(tableName, "le_last_update") + _serverMetadata.LEUserPrivKey = field.NewBytes(tableName, "le_user_priv_key") _serverMetadata.fillFieldMap() @@ -59,6 +60,7 @@ type serverMetadata struct { LEIssuerCertificate field.Bytes LECSR field.Bytes LELastUpdate field.Field + LEUserPrivKey field.Bytes fieldMap map[string]field.Expr } @@ -86,6 +88,7 @@ func (s *serverMetadata) updateTableName(table string) *serverMetadata { s.LEIssuerCertificate = field.NewBytes(table, "le_issuer_certificate") s.LECSR = field.NewBytes(table, "lecsr") s.LELastUpdate = field.NewField(table, "le_last_update") + s.LEUserPrivKey = field.NewBytes(table, "le_user_priv_key") s.fillFieldMap() @@ -102,7 +105,7 @@ func (s *serverMetadata) GetFieldByName(fieldName string) (field.OrderExpr, bool } func (s *serverMetadata) fillFieldMap() { - s.fieldMap = make(map[string]field.Expr, 11) + s.fieldMap = make(map[string]field.Expr, 12) s.fieldMap["id"] = s.Id s.fieldMap["created_at"] = s.CreatedAt s.fieldMap["updated_at"] = s.UpdatedAt @@ -114,6 +117,7 @@ func (s *serverMetadata) fillFieldMap() { s.fieldMap["le_issuer_certificate"] = s.LEIssuerCertificate s.fieldMap["lecsr"] = s.LECSR s.fieldMap["le_last_update"] = s.LELastUpdate + s.fieldMap["le_user_priv_key"] = s.LEUserPrivKey } func (s serverMetadata) clone(db *gorm.DB) serverMetadata { diff --git a/storage-new/dbgen/unhandled_messages.gen.go b/storage-new/dbgen/unhandled_messages.gen.go new file mode 100644 index 0000000..e869a00 --- /dev/null +++ b/storage-new/dbgen/unhandled_messages.gen.go @@ -0,0 +1,398 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package dbgen + +import ( + "context" + "database/sql" + + "git.mstar.dev/mstar/linstrom/storage-new/models" + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" +) + +func newUnhandledMessage(db *gorm.DB, opts ...gen.DOOption) unhandledMessage { + _unhandledMessage := unhandledMessage{} + + _unhandledMessage.unhandledMessageDo.UseDB(db, opts...) + _unhandledMessage.unhandledMessageDo.UseModel(&models.UnhandledMessage{}) + + tableName := _unhandledMessage.unhandledMessageDo.TableName() + _unhandledMessage.ALL = field.NewAsterisk(tableName) + _unhandledMessage.ID = field.NewUint64(tableName, "id") + _unhandledMessage.CreatedAt = field.NewTime(tableName, "created_at") + _unhandledMessage.RawData = field.NewBytes(tableName, "raw_data") + _unhandledMessage.ForUserId = field.NewString(tableName, "for_user_id") + _unhandledMessage.GlobalInbox = field.NewBool(tableName, "global_inbox") + + _unhandledMessage.fillFieldMap() + + return _unhandledMessage +} + +type unhandledMessage struct { + unhandledMessageDo + + ALL field.Asterisk + ID field.Uint64 + CreatedAt field.Time + RawData field.Bytes + ForUserId field.String + GlobalInbox field.Bool + + fieldMap map[string]field.Expr +} + +func (u unhandledMessage) Table(newTableName string) *unhandledMessage { + u.unhandledMessageDo.UseTable(newTableName) + return u.updateTableName(newTableName) +} + +func (u unhandledMessage) As(alias string) *unhandledMessage { + u.unhandledMessageDo.DO = *(u.unhandledMessageDo.As(alias).(*gen.DO)) + return u.updateTableName(alias) +} + +func (u *unhandledMessage) updateTableName(table string) *unhandledMessage { + u.ALL = field.NewAsterisk(table) + u.ID = field.NewUint64(table, "id") + u.CreatedAt = field.NewTime(table, "created_at") + u.RawData = field.NewBytes(table, "raw_data") + u.ForUserId = field.NewString(table, "for_user_id") + u.GlobalInbox = field.NewBool(table, "global_inbox") + + u.fillFieldMap() + + return u +} + +func (u *unhandledMessage) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := u.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (u *unhandledMessage) fillFieldMap() { + u.fieldMap = make(map[string]field.Expr, 5) + u.fieldMap["id"] = u.ID + u.fieldMap["created_at"] = u.CreatedAt + u.fieldMap["raw_data"] = u.RawData + u.fieldMap["for_user_id"] = u.ForUserId + u.fieldMap["global_inbox"] = u.GlobalInbox +} + +func (u unhandledMessage) clone(db *gorm.DB) unhandledMessage { + u.unhandledMessageDo.ReplaceConnPool(db.Statement.ConnPool) + return u +} + +func (u unhandledMessage) replaceDB(db *gorm.DB) unhandledMessage { + u.unhandledMessageDo.ReplaceDB(db) + return u +} + +type unhandledMessageDo struct{ gen.DO } + +type IUnhandledMessageDo interface { + gen.SubQuery + Debug() IUnhandledMessageDo + WithContext(ctx context.Context) IUnhandledMessageDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IUnhandledMessageDo + WriteDB() IUnhandledMessageDo + As(alias string) gen.Dao + Session(config *gorm.Session) IUnhandledMessageDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IUnhandledMessageDo + Not(conds ...gen.Condition) IUnhandledMessageDo + Or(conds ...gen.Condition) IUnhandledMessageDo + Select(conds ...field.Expr) IUnhandledMessageDo + Where(conds ...gen.Condition) IUnhandledMessageDo + Order(conds ...field.Expr) IUnhandledMessageDo + Distinct(cols ...field.Expr) IUnhandledMessageDo + Omit(cols ...field.Expr) IUnhandledMessageDo + Join(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo + LeftJoin(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo + RightJoin(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo + Group(cols ...field.Expr) IUnhandledMessageDo + Having(conds ...gen.Condition) IUnhandledMessageDo + Limit(limit int) IUnhandledMessageDo + Offset(offset int) IUnhandledMessageDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IUnhandledMessageDo + Unscoped() IUnhandledMessageDo + Create(values ...*models.UnhandledMessage) error + CreateInBatches(values []*models.UnhandledMessage, batchSize int) error + Save(values ...*models.UnhandledMessage) error + First() (*models.UnhandledMessage, error) + Take() (*models.UnhandledMessage, error) + Last() (*models.UnhandledMessage, error) + Find() ([]*models.UnhandledMessage, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.UnhandledMessage, err error) + FindInBatches(result *[]*models.UnhandledMessage, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*models.UnhandledMessage) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IUnhandledMessageDo + Assign(attrs ...field.AssignExpr) IUnhandledMessageDo + Joins(fields ...field.RelationField) IUnhandledMessageDo + Preload(fields ...field.RelationField) IUnhandledMessageDo + FirstOrInit() (*models.UnhandledMessage, error) + FirstOrCreate() (*models.UnhandledMessage, error) + FindByPage(offset int, limit int) (result []*models.UnhandledMessage, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IUnhandledMessageDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (u unhandledMessageDo) Debug() IUnhandledMessageDo { + return u.withDO(u.DO.Debug()) +} + +func (u unhandledMessageDo) WithContext(ctx context.Context) IUnhandledMessageDo { + return u.withDO(u.DO.WithContext(ctx)) +} + +func (u unhandledMessageDo) ReadDB() IUnhandledMessageDo { + return u.Clauses(dbresolver.Read) +} + +func (u unhandledMessageDo) WriteDB() IUnhandledMessageDo { + return u.Clauses(dbresolver.Write) +} + +func (u unhandledMessageDo) Session(config *gorm.Session) IUnhandledMessageDo { + return u.withDO(u.DO.Session(config)) +} + +func (u unhandledMessageDo) Clauses(conds ...clause.Expression) IUnhandledMessageDo { + return u.withDO(u.DO.Clauses(conds...)) +} + +func (u unhandledMessageDo) Returning(value interface{}, columns ...string) IUnhandledMessageDo { + return u.withDO(u.DO.Returning(value, columns...)) +} + +func (u unhandledMessageDo) Not(conds ...gen.Condition) IUnhandledMessageDo { + return u.withDO(u.DO.Not(conds...)) +} + +func (u unhandledMessageDo) Or(conds ...gen.Condition) IUnhandledMessageDo { + return u.withDO(u.DO.Or(conds...)) +} + +func (u unhandledMessageDo) Select(conds ...field.Expr) IUnhandledMessageDo { + return u.withDO(u.DO.Select(conds...)) +} + +func (u unhandledMessageDo) Where(conds ...gen.Condition) IUnhandledMessageDo { + return u.withDO(u.DO.Where(conds...)) +} + +func (u unhandledMessageDo) Order(conds ...field.Expr) IUnhandledMessageDo { + return u.withDO(u.DO.Order(conds...)) +} + +func (u unhandledMessageDo) Distinct(cols ...field.Expr) IUnhandledMessageDo { + return u.withDO(u.DO.Distinct(cols...)) +} + +func (u unhandledMessageDo) Omit(cols ...field.Expr) IUnhandledMessageDo { + return u.withDO(u.DO.Omit(cols...)) +} + +func (u unhandledMessageDo) Join(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo { + return u.withDO(u.DO.Join(table, on...)) +} + +func (u unhandledMessageDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo { + return u.withDO(u.DO.LeftJoin(table, on...)) +} + +func (u unhandledMessageDo) RightJoin(table schema.Tabler, on ...field.Expr) IUnhandledMessageDo { + return u.withDO(u.DO.RightJoin(table, on...)) +} + +func (u unhandledMessageDo) Group(cols ...field.Expr) IUnhandledMessageDo { + return u.withDO(u.DO.Group(cols...)) +} + +func (u unhandledMessageDo) Having(conds ...gen.Condition) IUnhandledMessageDo { + return u.withDO(u.DO.Having(conds...)) +} + +func (u unhandledMessageDo) Limit(limit int) IUnhandledMessageDo { + return u.withDO(u.DO.Limit(limit)) +} + +func (u unhandledMessageDo) Offset(offset int) IUnhandledMessageDo { + return u.withDO(u.DO.Offset(offset)) +} + +func (u unhandledMessageDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUnhandledMessageDo { + return u.withDO(u.DO.Scopes(funcs...)) +} + +func (u unhandledMessageDo) Unscoped() IUnhandledMessageDo { + return u.withDO(u.DO.Unscoped()) +} + +func (u unhandledMessageDo) Create(values ...*models.UnhandledMessage) error { + if len(values) == 0 { + return nil + } + return u.DO.Create(values) +} + +func (u unhandledMessageDo) CreateInBatches(values []*models.UnhandledMessage, batchSize int) error { + return u.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (u unhandledMessageDo) Save(values ...*models.UnhandledMessage) error { + if len(values) == 0 { + return nil + } + return u.DO.Save(values) +} + +func (u unhandledMessageDo) First() (*models.UnhandledMessage, error) { + if result, err := u.DO.First(); err != nil { + return nil, err + } else { + return result.(*models.UnhandledMessage), nil + } +} + +func (u unhandledMessageDo) Take() (*models.UnhandledMessage, error) { + if result, err := u.DO.Take(); err != nil { + return nil, err + } else { + return result.(*models.UnhandledMessage), nil + } +} + +func (u unhandledMessageDo) Last() (*models.UnhandledMessage, error) { + if result, err := u.DO.Last(); err != nil { + return nil, err + } else { + return result.(*models.UnhandledMessage), nil + } +} + +func (u unhandledMessageDo) Find() ([]*models.UnhandledMessage, error) { + result, err := u.DO.Find() + return result.([]*models.UnhandledMessage), err +} + +func (u unhandledMessageDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.UnhandledMessage, err error) { + buf := make([]*models.UnhandledMessage, 0, batchSize) + err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (u unhandledMessageDo) FindInBatches(result *[]*models.UnhandledMessage, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return u.DO.FindInBatches(result, batchSize, fc) +} + +func (u unhandledMessageDo) Attrs(attrs ...field.AssignExpr) IUnhandledMessageDo { + return u.withDO(u.DO.Attrs(attrs...)) +} + +func (u unhandledMessageDo) Assign(attrs ...field.AssignExpr) IUnhandledMessageDo { + return u.withDO(u.DO.Assign(attrs...)) +} + +func (u unhandledMessageDo) Joins(fields ...field.RelationField) IUnhandledMessageDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Joins(_f)) + } + return &u +} + +func (u unhandledMessageDo) Preload(fields ...field.RelationField) IUnhandledMessageDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Preload(_f)) + } + return &u +} + +func (u unhandledMessageDo) FirstOrInit() (*models.UnhandledMessage, error) { + if result, err := u.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*models.UnhandledMessage), nil + } +} + +func (u unhandledMessageDo) FirstOrCreate() (*models.UnhandledMessage, error) { + if result, err := u.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*models.UnhandledMessage), nil + } +} + +func (u unhandledMessageDo) FindByPage(offset int, limit int) (result []*models.UnhandledMessage, count int64, err error) { + result, err = u.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = u.Offset(-1).Limit(-1).Count() + return +} + +func (u unhandledMessageDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = u.Count() + if err != nil { + return + } + + err = u.Offset(offset).Limit(limit).Scan(result) + return +} + +func (u unhandledMessageDo) Scan(result interface{}) (err error) { + return u.DO.Scan(result) +} + +func (u unhandledMessageDo) Delete(models ...*models.UnhandledMessage) (result gen.ResultInfo, err error) { + return u.DO.Delete(models) +} + +func (u *unhandledMessageDo) withDO(do gen.Dao) *unhandledMessageDo { + u.DO = *do.(*gen.DO) + return u +} diff --git a/storage-new/dbgen/users.gen.go b/storage-new/dbgen/users.gen.go index e1c0656..91072bd 100644 --- a/storage-new/dbgen/users.gen.go +++ b/storage-new/dbgen/users.gen.go @@ -51,6 +51,7 @@ func newUser(db *gorm.DB, opts ...gen.DOOption) user { _user.FinishedRegistration = field.NewBool(tableName, "finished_registration") _user.PrivateKeyRsa = field.NewBytes(tableName, "private_key_rsa") _user.PrivateKeyEd = field.NewBytes(tableName, "private_key_ed") + _user.RawData = field.NewBytes(tableName, "raw_data") _user.RemoteInfoId = field.NewField(tableName, "remote_info_id") _user.RemoteInfo = userHasOneRemoteInfo{ db: db.Session(&gorm.Session{}), @@ -392,6 +393,7 @@ type user struct { FinishedRegistration field.Bool PrivateKeyRsa field.Bytes PrivateKeyEd field.Bytes + RawData field.Bytes RemoteInfoId field.Field RemoteInfo userHasOneRemoteInfo @@ -455,6 +457,7 @@ func (u *user) updateTableName(table string) *user { u.FinishedRegistration = field.NewBool(table, "finished_registration") u.PrivateKeyRsa = field.NewBytes(table, "private_key_rsa") u.PrivateKeyEd = field.NewBytes(table, "private_key_ed") + u.RawData = field.NewBytes(table, "raw_data") u.RemoteInfoId = field.NewField(table, "remote_info_id") u.fillFieldMap() @@ -472,7 +475,7 @@ func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) { } func (u *user) fillFieldMap() { - u.fieldMap = make(map[string]field.Expr, 36) + u.fieldMap = make(map[string]field.Expr, 37) u.fieldMap["id"] = u.ID u.fieldMap["username"] = u.Username u.fieldMap["created_at"] = u.CreatedAt @@ -496,6 +499,7 @@ func (u *user) fillFieldMap() { u.fieldMap["finished_registration"] = u.FinishedRegistration u.fieldMap["private_key_rsa"] = u.PrivateKeyRsa u.fieldMap["private_key_ed"] = u.PrivateKeyEd + u.fieldMap["raw_data"] = u.RawData u.fieldMap["remote_info_id"] = u.RemoteInfoId } diff --git a/storage-new/models/0allTypes.go b/storage-new/models/0allTypes.go index a6e0188..45caf62 100644 --- a/storage-new/models/0allTypes.go +++ b/storage-new/models/0allTypes.go @@ -23,6 +23,7 @@ var AllTypes = []any{ &ServerMetadata{}, &AccessToken{}, &LoginProcessToken{}, + &UnhandledMessage{}, &User{}, &UserAuthMethod{}, &UserToBeing{}, diff --git a/storage-new/models/ActivityToObject.go b/storage-new/models/ActivityToObject.go index 5ddb5b1..1a212cb 100644 --- a/storage-new/models/ActivityToObject.go +++ b/storage-new/models/ActivityToObject.go @@ -5,4 +5,6 @@ type Activity struct { Type string // `gorm:"type:activitystreams_activity_type"` ObjectId string ObjectType uint32 // Target type: ActivitystreamsActivityTargetType + + RawData []byte } diff --git a/storage-new/models/Note.go b/storage-new/models/Note.go index 8c7e351..ec6e9b0 100644 --- a/storage-new/models/Note.go +++ b/storage-new/models/Note.go @@ -34,6 +34,8 @@ type Note struct { PingRelations []NoteToPing `gorm:"foreignKey:NoteId;constraint:OnDelete:CASCADE"` // Pings/mentions this note performs Tags []NoteTag `gorm:"foreignKey:NoteId;constraint:OnDelete:CASCADE"` // Tags this note contains Edits []NoteEdit `gorm:"foreignKey:NoteId;constraint:OnDelete:CASCADE"` // All edits done to this note + + RawData []byte } type INote interface { diff --git a/storage-new/models/UnhandledMessage.go b/storage-new/models/UnhandledMessage.go new file mode 100644 index 0000000..cdefdb1 --- /dev/null +++ b/storage-new/models/UnhandledMessage.go @@ -0,0 +1,11 @@ +package models + +import "time" + +type UnhandledMessage struct { + ID uint64 `gorm:"primarykey"` + CreatedAt time.Time + RawData []byte // Raw data of the message + ForUserId string // Id of the user this message was for + GlobalInbox bool // Whether the message was sent to the global inbox +} diff --git a/storage-new/models/User.go b/storage-new/models/User.go index 61fce9a..eee5502 100644 --- a/storage-new/models/User.go +++ b/storage-new/models/User.go @@ -74,6 +74,8 @@ type User struct { PrivateKeyRsa []byte PrivateKeyEd []byte + RawData []byte + // ---- "Remote" linked values InfoFields []UserInfoField BeingTypes []UserToBeing diff --git a/web/public/api/activitypub/inbox.go b/web/public/api/activitypub/inbox.go index 3442561..280335b 100644 --- a/web/public/api/activitypub/inbox.go +++ b/web/public/api/activitypub/inbox.go @@ -89,6 +89,9 @@ func userInbox(w http.ResponseWriter, r *http.Request) { } log.Debug().Str("object-type", objectType).Msg("Inbox message") log.Trace().Bytes("body", body).Msg("Inbox raw message") + // TODO: Decide how to handle the handler failing for whatever reason + // Add object to unhandled message table and try again later? + // Discard it? And how would a handler return that it failed? switch objectType { case "Like": handleLike(w, r, data) @@ -103,7 +106,17 @@ func userInbox(w http.ResponseWriter, r *http.Request) { case "Create": handleCreate(w, r, data) default: - log.Warn().Str("object-type", objectType).Msg("Unknown message type") + log.Warn(). + Str("object-type", objectType). + Msg("Unknown message type, storing for later processing") + err = dbgen.UnhandledMessage.Create(&models.UnhandledMessage{ + ForUserId: userId, + GlobalInbox: false, + RawData: body, + }) + if err != nil { + log.Error().Err(err).Msg("Failed to store unhandled message for later") + } _ = webutils.ProblemDetailsStatusOnly(w, 500) } }