commit c74c14fda7827cea7f2e8ac63ac686815ec1c6c7 · veryroundbird.house/core

+5 -4

appview/db/db.go

···

       21
       21
        
       			domain text not null unique,

     

       22
       22
        
       			did text not null,

     

       23
       23
        
       			secret text not null,

     

       24
       24
       -
       			created integer default (strftime('%s', 'now')),

     

       25
       25
       -
       			registered integer);

     

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

     

       25
       25
       +
       			registered text

     

       26
       26
       +
       		);

     

       26
       27
        
       		create table if not exists public_keys (

     

       27
       28
        
       			id integer primary key autoincrement,

     

       28
       29
        
       			did text not null,

     

       29
       30
        
       			name text not null,

     

       30
       31
        
       			key text not null,

     

       31
       31
       -
       			created integer default (strftime('%s', 'now')),

     

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

     

       32
       33
        
       			unique(did, name, key)

     

       33
       34
        
       		);

     

       34
       35
        
       		create table if not exists repos (

     
···

       36
       37
        
       			did text not null,

     

       37
       38
        
       			name text not null,

     

       38
       39
        
       			knot text not null,

     

       39
       39
       -
       			created integer default (strftime('%s', 'now')),

     

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

     

       40
       41
        
       			unique(did, name, knot)

     

       41
       42
        
       		);

     

       42
       43
        
       	`)

+9 -7

appview/db/pubkeys.go

···

       21
       21
        
       	Did     string `json:"did"`

     

       22
       22
        
       	Key     string `json:"key"`

     

       23
       23
        
       	Name    string `json:"name"`

     

       24
       24
       -
       	Created time.Time

     

       24
       24
       +
       	Created *time.Time

     

       25
       25
        
       }

     

       26
       26
        
       

     

       27
       27
        
       func (p PublicKey) MarshalJSON() ([]byte, error) {

     

       28
       28
        
       	type Alias PublicKey

     

       29
       29
        
       	return json.Marshal(&struct {

     

       30
       30
       -
       		Created int64 `json:"created"`

     

       30
       30
       +
       		Created string `json:"created"`

     

       31
       31
        
       		*Alias

     

       32
       32
        
       	}{

     

       33
       33
       -
       		Created: p.Created.Unix(),

     

       33
       33
       +
       		Created: p.Created.Format(time.RFC3339),

     

       34
       34
        
       		Alias:   (*Alias)(&p),

     

       35
       35
        
       	})

     

       36
       36
        
       }

     
···

       46
       46
        
       

     

       47
       47
        
       	for rows.Next() {

     

       48
       48
        
       		var publicKey PublicKey

     

       49
       49
       -
       		var createdAt *int64

     

       49
       49
       +
       		var createdAt string

     

       50
       50
        
       		if err := rows.Scan(&publicKey.Key, &publicKey.Name, &publicKey.Did, &createdAt); err != nil {

     

       51
       51
        
       			return nil, err

     

       52
       52
        
       		}

     

       53
       53
       -
       		publicKey.Created = time.Unix(*createdAt, 0)

     

       53
       53
       +
       		createdAtTime, _ := time.Parse(time.RFC3339, createdAt)

     

       54
       54
       +
       		publicKey.Created = &createdAtTime

     

       54
       55
        
       		keys = append(keys, publicKey)

     

       55
       56
        
       	}

     

       56
       57
        
       

     
···

       72
       73
        
       

     

       73
       74
        
       	for rows.Next() {

     

       74
       75
        
       		var publicKey PublicKey

     

       75
       75
       -
       		var createdAt *int64

     

       76
       76
       +
       		var createdAt string

     

       76
       77
        
       		if err := rows.Scan(&publicKey.Did, &publicKey.Key, &publicKey.Name, &createdAt); err != nil {

     

       77
       78
        
       			return nil, err

     

       78
       79
        
       		}

     

       79
       79
       -
       		publicKey.Created = time.Unix(*createdAt, 0)

     

       80
       80
       +
       		createdAtTime, _ := time.Parse(time.RFC3339, createdAt)

     

       81
       81
       +
       		publicKey.Created = &createdAtTime

     

       80
       82
        
       		keys = append(keys, publicKey)

     

       81
       83
        
       	}

     

       82
       84

+9 -10

appview/db/registration.go

···

       44
       44
        
       	}

     

       45
       45
        
       

     

       46
       46
        
       	for rows.Next() {

     

       47
       47
       -
       		var createdAt *int64

     

       48
       48
       -
       		var registeredAt *int64

     

       47
       47
       +
       		var createdAt *string

     

       48
       48
       +
       		var registeredAt *string

     

       49
       49
        
       		var registration Registration

     

       50
       50
        
       		err = rows.Scan(&registration.Domain, &registration.ByDid, &createdAt, &registeredAt)

     

       51
       51
        
       

     

       52
       52
        
       		if err != nil {

     

       53
       53
        
       			log.Println(err)

     

       54
       54
        
       		} else {

     

       55
       55
       -
       			createdAtTime := time.Unix(*createdAt, 0)

     

       56
       56
       -
       

     

       55
       55
       +
       			createdAtTime, _ := time.Parse(time.RFC3339, *createdAt)

     

       57
       56
        
       			var registeredAtTime *time.Time

     

       58
       57
        
       			if registeredAt != nil {

     

       59
       59
       -
       				x := time.Unix(*registeredAt, 0)

     

       58
       58
       +
       				x, _ := time.Parse(time.RFC3339, *registeredAt)

     

       60
       59
        
       				registeredAtTime = &x

     

       61
       60
        
       			}

     

       62
       61
        
       

     
···

       71
       70
        
       

     

       72
       71
        
       // returns registered status, did of owner, error

     

       73
       72
        
       func (d *DB) RegistrationByDomain(domain string) (*Registration, error) {

     

       74
       74
       -
       	var createdAt *int64

     

       75
       75
       -
       	var registeredAt *int64

     

       73
       73
       +
       	var createdAt *string

     

       74
       74
       +
       	var registeredAt *string

     

       76
       75
        
       	var registration Registration

     

       77
       76
        
       

     

       78
       77
        
       	err := d.db.QueryRow(`

     
···

       88
       87
        
       		}

     

       89
       88
        
       	}

     

       90
       89
        
       

     

       91
       91
       -
       	createdAtTime := time.Unix(*createdAt, 0)

     

       90
       90
       +
       	createdAtTime, _ := time.Parse(time.RFC3339, *createdAt)

     

       92
       91
        
       	var registeredAtTime *time.Time

     

       93
       92
        
       	if registeredAt != nil {

     

       94
       94
       -
       		x := time.Unix(*registeredAt, 0)

     

       93
       93
       +
       		x, _ := time.Parse(time.RFC3339, *registeredAt)

     

       95
       94
        
       		registeredAtTime = &x

     

       96
       95
        
       	}

     

       97
       96
        
       

     
···

       156
       155
        
       func (d *DB) Register(domain string) error {

     

       157
       156
        
       	_, err := d.db.Exec(`

     

       158
       157
        
       		update registrations

     

       159
       159
       -
       		set registered = strftime('%s', 'now')

     

       158
       158
       +
       		set registered = strftime('%Y-%m-%dT%H:%M:%SZ', 'now')

     

       160
       159
        
       		where domain = ?;

     

       161
       160
        
       		`, domain)

     

       162
       161

+10 -5

appview/db/repos.go

···

       1
       1
        
       package db

     

       2
       2
        
       

     

       3
       3
       +
       import "time"

     

       4
       4
       +
       

     

       3
       5
        
       type Repo struct {

     

       4
       6
        
       	Did     string

     

       5
       7
        
       	Name    string

     

       6
       8
        
       	Knot    string

     

       7
       7
       -
       	Created *int64

     

       9
       9
       +
       	Created *time.Time

     

       8
       10
        
       }

     

       9
       11
        
       

     

       10
       12
        
       func (d *DB) GetAllReposByDid(did string) ([]Repo, error) {

     
···

       18
       20
        
       

     

       19
       21
        
       	for rows.Next() {

     

       20
       22
        
       		var repo Repo

     

       21
       21
       -
       		var createdAt *int64

     

       23
       23
       +
       		var createdAt string

     

       22
       24
        
       		if err := rows.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt); err != nil {

     

       23
       25
        
       			return nil, err

     

       24
       26
        
       		}

     

       25
       25
       -
       		repo.Created = createdAt

     

       27
       27
       +
       		createdAtTime, _ := time.Parse(time.RFC3339, createdAt)

     

       28
       28
       +
       		repo.Created = &createdAtTime

     

       26
       29
        
       		repos = append(repos, repo)

     

       27
       30
        
       	}

     

       28
       31
        
       

     
···

       37
       40
        
       	var repo Repo

     

       38
       41
        
       

     

       39
       42
        
       	row := d.db.QueryRow(`select did, name, knot, created from repos where did = ? and name = ?`, did, name)

     

       40
       40
       -
       	var createdAt *int64

     

       43
       43
       +
       

     

       44
       44
       +
       	var createdAt string

     

       41
       45
        
       	if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt); err != nil {

     

       42
       46
        
       		return nil, err

     

       43
       47
        
       	}

     

       44
       44
       -
       	repo.Created = createdAt

     

       48
       48
       +
       	createdAtTime, _ := time.Parse(time.RFC3339, createdAt)

     

       49
       49
       +
       	repo.Created = &createdAtTime

     

       45
       50
        
       

     

       46
       51
        
       	return &repo, nil

     

       47
       52
        
       }

+1

appview/state/middleware.go

···

       34
       34
        
       			expiry, err := time.Parse(time.RFC3339, expiryStr)

     

       35
       35
        
       			if err != nil {

     

       36
       36
        
       				log.Println("invalid expiry time", err)

     

       37
       37
       +
       				http.Redirect(w, r, "/login", http.StatusTemporaryRedirect)

     

       37
       38
        
       				return

     

       38
       39
        
       			}

     

       39
       40
        
       			pdsUrl := session.Values[appview.SessionPds].(string)

+2 -2

knotserver/db/init.go

···

       25
       25
        
       			id integer primary key autoincrement,

     

       26
       26
        
       			did text not null,

     

       27
       27
        
       			key text not null,

     

       28
       28
       -
       			created timestamp default current_timestamp,

     

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

     

       29
       29
        
       			unique(did, key),

     

       30
       30
        
       			foreign key (did) references known_dids(did) on delete cascade

     

       31
       31
        
       		);

     
···

       35
       35
        
       			did text not null,

     

       36
       36
        
       			name text not null,

     

       37
       37
        
       			description text not null,

     

       38
       38
       -
       			created timestamp default current_timestamp,

     

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

     

       39
       39
        
       			unique(did, name)

     

       40
       40
        
       		);

     

       41
       41

+1 -1

knotserver/db/pubkeys.go

···

       30
       30
        
       

     

       31
       31
        
       func (d *DB) AddPublicKey(pk PublicKey) error {

     

       32
       32
        
       	if pk.Created == "" {

     

       33
       33
       -
       		pk.Created = time.Now().Format("2006-01-02 15:04:05.99999999 -0700 MST m=-0000.000000000")

     

       33
       33
       +
       		pk.Created = time.Now().Format(time.RFC3339)

     

       34
       34
        
       	}

     

       35
       35
        
       

     

       36
       36
        
       	query := `insert or ignore into public_keys (did, key, created) values (?, ?, ?)`