commit f1a8e659301d1932b85f5aae004a0ada67d2fd06 · nel.pet/core

+17 -1

appview/db/db.go

···

       330
       330
        
       			verified text, -- time of verification

     

       331
       331
        
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       332
       332
        
       

     

       333
       333
       -
       			unique(instance)

     

       333
       333
       +
       			unique(did, instance)

     

       334
       334
       +
       		);

     

       335
       335
       +
       

     

       336
       336
       +
       		create table if not exists spindle_members (

     

       337
       337
       +
       			-- identifiers for the record

     

       338
       338
       +
       			id integer primary key autoincrement,

     

       339
       339
       +
       			did text not null,

     

       340
       340
       +
       			rkey text not null,

     

       341
       341
       +
       

     

       342
       342
       +
       			-- data

     

       343
       343
       +
       			instance text not null,

     

       344
       344
       +
       			subject text not null,

     

       345
       345
       +
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       346
       346
       +
       

     

       347
       347
       +
       			-- constraints

     

       348
       348
       +
       			foreign key (did, instance) references spindles(owner, instance) on delete cascade,

     

       349
       349
       +
       			unique (did, instance, subject)

     

       334
       350
        
       		);

     

       335
       351
        
       

     

       336
       352
        
       		create table if not exists pipelines (

+96

appview/db/spindle.go

···

       17
       17
        
       	Created  time.Time

     

       18
       18
        
       }

     

       19
       19
        
       

     

       20
       20
       +
       type SpindleMember struct {

     

       21
       21
       +
       	Id       int

     

       22
       22
       +
       	Did      syntax.DID // owner of the record

     

       23
       23
       +
       	Rkey     string     // rkey of the record

     

       24
       24
       +
       	Instance string

     

       25
       25
       +
       	Subject  syntax.DID // the member being added

     

       26
       26
       +
       	Created  time.Time

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       20
       29
        
       func GetSpindles(e Execer, filters ...filter) ([]Spindle, error) {

     

       21
       30
        
       	var spindles []Spindle

     

       22
       31
        
       

     
···

       134
       143
        
       	_, err := e.Exec(query, args...)

     

       135
       144
        
       	return err

     

       136
       145
        
       }

     

       146
       146
       +
       

     

       147
       147
       +
       func AddSpindleMember(e Execer, member SpindleMember) error {

     

       148
       148
       +
       	_, err := e.Exec(

     

       149
       149
       +
       		`insert or ignore into spindle_members (did, rkey, instance, subject) values (?, ?, ?, ?)`,

     

       150
       150
       +
       		member.Did,

     

       151
       151
       +
       		member.Rkey,

     

       152
       152
       +
       		member.Instance,

     

       153
       153
       +
       		member.Subject,

     

       154
       154
       +
       	)

     

       155
       155
       +
       	return err

     

       156
       156
       +
       }

     

       157
       157
       +
       

     

       158
       158
       +
       func RemoveSpindleMember(e Execer, filters ...filter) error {

     

       159
       159
       +
       	var conditions []string

     

       160
       160
       +
       	var args []any

     

       161
       161
       +
       	for _, filter := range filters {

     

       162
       162
       +
       		conditions = append(conditions, filter.Condition())

     

       163
       163
       +
       		args = append(args, filter.Arg()...)

     

       164
       164
       +
       	}

     

       165
       165
       +
       

     

       166
       166
       +
       	whereClause := ""

     

       167
       167
       +
       	if conditions != nil {

     

       168
       168
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       169
       169
       +
       	}

     

       170
       170
       +
       

     

       171
       171
       +
       	query := fmt.Sprintf(`delete from spindle_members %s`, whereClause)

     

       172
       172
       +
       

     

       173
       173
       +
       	_, err := e.Exec(query, args...)

     

       174
       174
       +
       	return err

     

       175
       175
       +
       }

     

       176
       176
       +
       

     

       177
       177
       +
       func GetSpindleMembers(e Execer, filters ...filter) ([]SpindleMember, error) {

     

       178
       178
       +
       	var members []SpindleMember

     

       179
       179
       +
       

     

       180
       180
       +
       	var conditions []string

     

       181
       181
       +
       	var args []any

     

       182
       182
       +
       	for _, filter := range filters {

     

       183
       183
       +
       		conditions = append(conditions, filter.Condition())

     

       184
       184
       +
       		args = append(args, filter.Arg()...)

     

       185
       185
       +
       	}

     

       186
       186
       +
       

     

       187
       187
       +
       	whereClause := ""

     

       188
       188
       +
       	if conditions != nil {

     

       189
       189
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       190
       190
       +
       	}

     

       191
       191
       +
       

     

       192
       192
       +
       	query := fmt.Sprintf(

     

       193
       193
       +
       		`select id, did, rkey, instance, subject, created

     

       194
       194
       +
       		from spindle_members

     

       195
       195
       +
       		%s

     

       196
       196
       +
       		order by created

     

       197
       197
       +
       		`,

     

       198
       198
       +
       		whereClause,

     

       199
       199
       +
       	)

     

       200
       200
       +
       

     

       201
       201
       +
       	rows, err := e.Query(query, args...)

     

       202
       202
       +
       

     

       203
       203
       +
       	if err != nil {

     

       204
       204
       +
       		return nil, err

     

       205
       205
       +
       	}

     

       206
       206
       +
       	defer rows.Close()

     

       207
       207
       +
       

     

       208
       208
       +
       	for rows.Next() {

     

       209
       209
       +
       		var member SpindleMember

     

       210
       210
       +
       		var createdAt string

     

       211
       211
       +
       

     

       212
       212
       +
       		if err := rows.Scan(

     

       213
       213
       +
       			&member.Id,

     

       214
       214
       +
       			&member.Did,

     

       215
       215
       +
       			&member.Rkey,

     

       216
       216
       +
       			&member.Instance,

     

       217
       217
       +
       			&member.Subject,

     

       218
       218
       +
       			&createdAt,

     

       219
       219
       +
       		); err != nil {

     

       220
       220
       +
       			return nil, err

     

       221
       221
       +
       		}

     

       222
       222
       +
       

     

       223
       223
       +
       		member.Created, err = time.Parse(time.RFC3339, createdAt)

     

       224
       224
       +
       		if err != nil {

     

       225
       225
       +
       			member.Created = time.Now()

     

       226
       226
       +
       		}

     

       227
       227
       +
       

     

       228
       228
       +
       		members = append(members, member)

     

       229
       229
       +
       	}

     

       230
       230
       +
       

     

       231
       231
       +
       	return members, nil

     

       232
       232
       +
       }