1
0
Fork 0
miniflux/storage/user.go

590 lines
13 KiB
Go
Raw Normal View History

2017-11-20 00:10:04 -05:00
// Copyright 2017 Frédéric Guillot. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
2018-08-25 00:51:50 -04:00
package storage // import "miniflux.app/storage"
2017-11-20 00:10:04 -05:00
import (
"database/sql"
"fmt"
2020-12-23 00:02:10 -05:00
"runtime"
2017-11-20 00:10:04 -05:00
"strings"
"miniflux.app/logger"
2018-08-25 00:51:50 -04:00
"miniflux.app/model"
2017-11-23 01:22:33 -05:00
"github.com/lib/pq"
2017-11-20 00:10:04 -05:00
"golang.org/x/crypto/bcrypt"
)
2020-09-27 19:01:06 -04:00
// CountUsers returns the total number of users.
func (s *Storage) CountUsers() int {
var result int
err := s.db.QueryRow(`SELECT count(*) FROM users`).Scan(&result)
if err != nil {
return 0
}
return result
}
2017-11-28 00:30:04 -05:00
// SetLastLogin updates the last login date of a user.
2017-11-20 00:10:04 -05:00
func (s *Storage) SetLastLogin(userID int64) error {
2019-10-30 01:48:07 -04:00
query := `UPDATE users SET last_login_at=now() WHERE id=$1`
2017-11-20 00:10:04 -05:00
_, err := s.db.Exec(query, userID)
if err != nil {
2019-10-30 01:48:07 -04:00
return fmt.Errorf(`store: unable to update last login date: %v`, err)
2017-11-20 00:10:04 -05:00
}
return nil
}
2017-11-28 00:30:04 -05:00
// UserExists checks if a user exists by using the given username.
2017-11-20 00:10:04 -05:00
func (s *Storage) UserExists(username string) bool {
2019-10-30 01:48:07 -04:00
var result bool
s.db.QueryRow(`SELECT true FROM users WHERE username=LOWER($1)`, username).Scan(&result)
return result
2017-11-20 00:10:04 -05:00
}
2017-11-28 00:30:04 -05:00
// AnotherUserExists checks if another user exists with the given username.
2017-11-20 00:10:04 -05:00
func (s *Storage) AnotherUserExists(userID int64, username string) bool {
2019-10-30 01:48:07 -04:00
var result bool
s.db.QueryRow(`SELECT true FROM users WHERE id != $1 AND username=LOWER($2)`, userID, username).Scan(&result)
return result
2017-11-20 00:10:04 -05:00
}
2017-11-28 00:30:04 -05:00
// CreateUser creates a new user.
func (s *Storage) CreateUser(userCreationRequest *model.UserCreationRequest) (*model.User, error) {
var hashedPassword string
if userCreationRequest.Password != "" {
var err error
hashedPassword, err = hashPassword(userCreationRequest.Password)
2017-11-23 01:22:33 -05:00
if err != nil {
return nil, err
2017-11-23 01:22:33 -05:00
}
2017-11-20 00:10:04 -05:00
}
query := `
INSERT INTO users
(username, password, is_admin, google_id, openid_connect_id)
2017-11-25 13:40:23 -05:00
VALUES
(LOWER($1), $2, $3, $4, $5)
RETURNING
id,
username,
is_admin,
language,
theme,
timezone,
entry_direction,
entries_per_page,
keyboard_shortcuts,
show_reading_time,
entry_swipe,
stylesheet,
google_id,
openid_connect_id
`
2017-11-25 13:40:23 -05:00
tx, err := s.db.Begin()
if err != nil {
return nil, fmt.Errorf(`store: unable to start transaction: %v`, err)
}
var user model.User
err = tx.QueryRow(
query,
userCreationRequest.Username,
hashedPassword,
userCreationRequest.IsAdmin,
userCreationRequest.GoogleID,
userCreationRequest.OpenIDConnectID,
).Scan(
2017-11-25 13:40:23 -05:00
&user.ID,
&user.Username,
&user.IsAdmin,
2017-11-25 13:40:23 -05:00
&user.Language,
&user.Theme,
&user.Timezone,
2017-12-24 21:04:34 -05:00
&user.EntryDirection,
&user.EntriesPerPage,
&user.KeyboardShortcuts,
2020-07-16 22:46:24 -04:00
&user.ShowReadingTime,
&user.EntrySwipe,
&user.Stylesheet,
&user.GoogleID,
&user.OpenIDConnectID,
2017-11-25 13:40:23 -05:00
)
2017-11-20 00:10:04 -05:00
if err != nil {
tx.Rollback()
return nil, fmt.Errorf(`store: unable to create user: %v`, err)
2017-11-20 00:10:04 -05:00
}
_, err = tx.Exec(`INSERT INTO categories (user_id, title) VALUES ($1, $2)`, user.ID, "All")
if err != nil {
tx.Rollback()
return nil, fmt.Errorf(`store: unable to create user default category: %v`, err)
}
_, err = tx.Exec(`INSERT INTO integrations (user_id) VALUES ($1)`, user.ID)
if err != nil {
tx.Rollback()
return nil, fmt.Errorf(`store: unable to create integration row: %v`, err)
}
if err := tx.Commit(); err != nil {
return nil, fmt.Errorf(`store: unable to commit transaction: %v`, err)
}
return &user, nil
2017-11-20 00:10:04 -05:00
}
2017-11-28 00:30:04 -05:00
// UpdateUser updates a user.
2017-11-20 00:10:04 -05:00
func (s *Storage) UpdateUser(user *model.User) error {
if user.Password != "" {
hashedPassword, err := hashPassword(user.Password)
if err != nil {
return err
}
query := `
UPDATE users SET
username=LOWER($1),
password=$2,
is_admin=$3,
theme=$4,
language=$5,
timezone=$6,
entry_direction=$7,
entries_per_page=$8,
2020-07-16 22:46:24 -04:00
keyboard_shortcuts=$9,
show_reading_time=$10,
entry_swipe=$11,
stylesheet=$12,
google_id=$13,
openid_connect_id=$14
WHERE
id=$15
`
2017-12-02 20:04:01 -05:00
_, err = s.db.Exec(
query,
user.Username,
hashedPassword,
user.IsAdmin,
user.Theme,
user.Language,
user.Timezone,
user.EntryDirection,
user.EntriesPerPage,
user.KeyboardShortcuts,
2020-07-16 22:46:24 -04:00
user.ShowReadingTime,
user.EntrySwipe,
user.Stylesheet,
user.GoogleID,
user.OpenIDConnectID,
2017-12-02 20:04:01 -05:00
user.ID,
)
2017-11-20 00:10:04 -05:00
if err != nil {
2019-10-30 01:48:07 -04:00
return fmt.Errorf(`store: unable to update user: %v`, err)
2017-11-20 00:10:04 -05:00
}
} else {
query := `
UPDATE users SET
username=LOWER($1),
is_admin=$2,
theme=$3,
language=$4,
timezone=$5,
entry_direction=$6,
entries_per_page=$7,
2020-07-16 22:46:24 -04:00
keyboard_shortcuts=$8,
show_reading_time=$9,
entry_swipe=$10,
stylesheet=$11,
google_id=$12,
openid_connect_id=$13
WHERE
id=$14
`
2017-12-02 20:04:01 -05:00
_, err := s.db.Exec(
query,
user.Username,
user.IsAdmin,
user.Theme,
user.Language,
user.Timezone,
user.EntryDirection,
user.EntriesPerPage,
user.KeyboardShortcuts,
2020-07-16 22:46:24 -04:00
user.ShowReadingTime,
user.EntrySwipe,
user.Stylesheet,
user.GoogleID,
user.OpenIDConnectID,
2017-12-02 20:04:01 -05:00
user.ID,
)
2017-11-20 00:10:04 -05:00
if err != nil {
2019-10-30 01:48:07 -04:00
return fmt.Errorf(`store: unable to update user: %v`, err)
2017-11-20 00:10:04 -05:00
}
}
2020-03-30 19:54:02 -04:00
2017-11-20 00:10:04 -05:00
return nil
}
// UserLanguage returns the language of the given user.
func (s *Storage) UserLanguage(userID int64) (language string) {
err := s.db.QueryRow(`SELECT language FROM users WHERE id = $1`, userID).Scan(&language)
if err != nil {
return "en_US"
}
return language
}
2017-11-28 00:30:04 -05:00
// UserByID finds a user by the ID.
func (s *Storage) UserByID(userID int64) (*model.User, error) {
query := `
SELECT
2019-10-30 01:48:07 -04:00
id,
username,
is_admin,
theme,
language,
timezone,
entry_direction,
entries_per_page,
2019-10-30 01:48:07 -04:00
keyboard_shortcuts,
2020-07-16 22:46:24 -04:00
show_reading_time,
entry_swipe,
2019-10-30 01:48:07 -04:00
last_login_at,
stylesheet,
google_id,
openid_connect_id
FROM
users
WHERE
id = $1
`
2017-12-29 16:53:02 -05:00
return s.fetchUser(query, userID)
2017-11-20 00:10:04 -05:00
}
2017-11-28 00:30:04 -05:00
// UserByUsername finds a user by the username.
func (s *Storage) UserByUsername(username string) (*model.User, error) {
query := `
SELECT
2019-10-30 01:48:07 -04:00
id,
username,
is_admin,
theme,
language,
timezone,
entry_direction,
entries_per_page,
2019-10-30 01:48:07 -04:00
keyboard_shortcuts,
2020-07-16 22:46:24 -04:00
show_reading_time,
entry_swipe,
2019-10-30 01:48:07 -04:00
last_login_at,
stylesheet,
google_id,
openid_connect_id
FROM
users
WHERE
username=LOWER($1)
`
2017-12-29 16:53:02 -05:00
return s.fetchUser(query, username)
2017-11-23 01:22:33 -05:00
}
// UserByField finds a user by a field value.
func (s *Storage) UserByField(field, value string) (*model.User, error) {
query := `
SELECT
2019-10-30 01:48:07 -04:00
id,
username,
is_admin,
theme,
language,
timezone,
entry_direction,
entries_per_page,
2019-10-30 01:48:07 -04:00
keyboard_shortcuts,
2020-07-16 22:46:24 -04:00
show_reading_time,
entry_swipe,
2019-10-30 01:48:07 -04:00
last_login_at,
stylesheet,
google_id,
openid_connect_id
FROM
users
WHERE
%s=$1
`
return s.fetchUser(fmt.Sprintf(query, pq.QuoteIdentifier(field)), value)
}
// AnotherUserWithFieldExists returns true if a user has the value set for the given field.
func (s *Storage) AnotherUserWithFieldExists(userID int64, field, value string) bool {
var result bool
s.db.QueryRow(fmt.Sprintf(`SELECT true FROM users WHERE id <> $1 AND %s=$2`, pq.QuoteIdentifier(field)), userID, value).Scan(&result)
return result
2017-12-29 16:53:02 -05:00
}
2020-03-01 20:38:29 -05:00
// UserByAPIKey returns a User from an API Key.
func (s *Storage) UserByAPIKey(token string) (*model.User, error) {
query := `
SELECT
u.id,
u.username,
u.is_admin,
u.theme,
u.language,
u.timezone,
u.entry_direction,
u.entries_per_page,
2020-03-01 20:38:29 -05:00
u.keyboard_shortcuts,
2020-07-16 22:46:24 -04:00
u.show_reading_time,
u.entry_swipe,
2020-03-01 20:38:29 -05:00
u.last_login_at,
u.stylesheet,
u.google_id,
u.openid_connect_id
2020-03-01 20:38:29 -05:00
FROM
users u
LEFT JOIN
api_keys ON api_keys.user_id=u.id
WHERE
api_keys.token = $1
`
return s.fetchUser(query, token)
}
2017-12-29 16:53:02 -05:00
func (s *Storage) fetchUser(query string, args ...interface{}) (*model.User, error) {
var user model.User
2017-12-29 16:53:02 -05:00
err := s.db.QueryRow(query, args...).Scan(
2017-12-02 20:04:01 -05:00
&user.ID,
&user.Username,
&user.IsAdmin,
&user.Theme,
&user.Language,
&user.Timezone,
&user.EntryDirection,
&user.EntriesPerPage,
&user.KeyboardShortcuts,
2020-07-16 22:46:24 -04:00
&user.ShowReadingTime,
&user.EntrySwipe,
2017-12-29 16:53:02 -05:00
&user.LastLoginAt,
&user.Stylesheet,
&user.GoogleID,
&user.OpenIDConnectID,
2017-12-02 20:04:01 -05:00
)
2017-12-29 16:53:02 -05:00
2017-11-23 01:22:33 -05:00
if err == sql.ErrNoRows {
return nil, nil
} else if err != nil {
2019-10-30 01:48:07 -04:00
return nil, fmt.Errorf(`store: unable to fetch user: %v`, err)
2017-11-20 00:10:04 -05:00
}
return &user, nil
2017-11-20 00:10:04 -05:00
}
2017-11-28 00:30:04 -05:00
// RemoveUser deletes a user.
2017-11-20 00:10:04 -05:00
func (s *Storage) RemoveUser(userID int64) error {
tx, err := s.db.Begin()
2017-11-20 00:10:04 -05:00
if err != nil {
return fmt.Errorf(`store: unable to start transaction: %v`, err)
2017-11-20 00:10:04 -05:00
}
if _, err := tx.Exec(`DELETE FROM users WHERE id=$1`, userID); err != nil {
tx.Rollback()
return fmt.Errorf(`store: unable to remove user #%d: %v`, userID, err)
}
if _, err := tx.Exec(`DELETE FROM integrations WHERE user_id=$1`, userID); err != nil {
tx.Rollback()
return fmt.Errorf(`store: unable to remove integration settings for user #%d: %v`, userID, err)
2017-11-20 00:10:04 -05:00
}
if err := tx.Commit(); err != nil {
return fmt.Errorf(`store: unable to commit transaction: %v`, err)
2017-11-20 00:10:04 -05:00
}
return nil
}
// RemoveUserAsync deletes user data without locking the database.
func (s *Storage) RemoveUserAsync(userID int64) {
go func() {
deleteUserFeeds(s.db, userID)
s.db.Exec(`DELETE FROM users WHERE id=$1`, userID)
s.db.Exec(`DELETE FROM integrations WHERE user_id=$1`, userID)
2020-12-23 00:02:10 -05:00
logger.Debug(`[MASS DELETE] User #%d has been deleted (%d GoRoutines)`, userID, runtime.NumGoroutine())
}()
}
2017-11-28 00:30:04 -05:00
// Users returns all users.
func (s *Storage) Users() (model.Users, error) {
2017-12-29 16:53:02 -05:00
query := `
SELECT
2019-10-30 01:48:07 -04:00
id,
username,
is_admin,
theme,
language,
timezone,
entry_direction,
entries_per_page,
2019-10-30 01:48:07 -04:00
keyboard_shortcuts,
2020-07-16 22:46:24 -04:00
show_reading_time,
entry_swipe,
2019-10-30 01:48:07 -04:00
last_login_at,
stylesheet,
google_id,
openid_connect_id
FROM
users
ORDER BY username ASC
`
2017-12-02 20:04:01 -05:00
rows, err := s.db.Query(query)
2017-11-20 00:10:04 -05:00
if err != nil {
2019-10-30 01:48:07 -04:00
return nil, fmt.Errorf(`store: unable to fetch users: %v`, err)
2017-11-20 00:10:04 -05:00
}
defer rows.Close()
2017-12-02 20:04:01 -05:00
var users model.Users
2017-11-20 00:10:04 -05:00
for rows.Next() {
var user model.User
2017-11-20 00:10:04 -05:00
err := rows.Scan(
&user.ID,
&user.Username,
&user.IsAdmin,
&user.Theme,
&user.Language,
&user.Timezone,
2017-12-29 16:53:02 -05:00
&user.EntryDirection,
&user.EntriesPerPage,
&user.KeyboardShortcuts,
2020-07-16 22:46:24 -04:00
&user.ShowReadingTime,
&user.EntrySwipe,
2017-11-20 00:10:04 -05:00
&user.LastLoginAt,
&user.Stylesheet,
&user.GoogleID,
&user.OpenIDConnectID,
2017-11-20 00:10:04 -05:00
)
if err != nil {
2019-10-30 01:48:07 -04:00
return nil, fmt.Errorf(`store: unable to fetch users row: %v`, err)
2017-11-20 00:10:04 -05:00
}
users = append(users, &user)
2017-11-20 00:10:04 -05:00
}
return users, nil
}
2017-11-28 00:30:04 -05:00
// CheckPassword validate the hashed password.
2017-11-20 00:10:04 -05:00
func (s *Storage) CheckPassword(username, password string) error {
var hash string
username = strings.ToLower(username)
err := s.db.QueryRow("SELECT password FROM users WHERE username=$1", username).Scan(&hash)
if err == sql.ErrNoRows {
2019-10-30 01:48:07 -04:00
return fmt.Errorf(`store: unable to find this user: %s`, username)
2017-11-20 00:10:04 -05:00
} else if err != nil {
2019-10-30 01:48:07 -04:00
return fmt.Errorf(`store: unable to fetch user: %v`, err)
2017-11-20 00:10:04 -05:00
}
if err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password)); err != nil {
2019-10-30 01:48:07 -04:00
return fmt.Errorf(`store: invalid password for "%s" (%v)`, username, err)
2017-11-20 00:10:04 -05:00
}
return nil
}
// HasPassword returns true if the given user has a password defined.
func (s *Storage) HasPassword(userID int64) (bool, error) {
var result bool
query := `SELECT true FROM users WHERE id=$1 AND password <> ''`
err := s.db.QueryRow(query, userID).Scan(&result)
if err == sql.ErrNoRows {
return false, nil
} else if err != nil {
2019-10-30 01:48:07 -04:00
return false, fmt.Errorf(`store: unable to execute query: %v`, err)
}
if result {
return true, nil
}
return false, nil
}
2017-11-20 00:10:04 -05:00
func hashPassword(password string) (string, error) {
bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
return string(bytes), err
}
func deleteUserFeeds(db *sql.DB, userID int64) {
query := `SELECT id FROM feeds WHERE user_id=$1`
rows, err := db.Query(query, userID)
if err != nil {
logger.Error(`store: unable to get user feeds: %v`, err)
return
}
defer rows.Close()
var feedIDs []int64
for rows.Next() {
var feedID int64
rows.Scan(&feedID)
feedIDs = append(feedIDs, feedID)
}
worker := func(jobs <-chan int64, results chan<- bool) {
for feedID := range jobs {
2020-12-23 00:02:10 -05:00
logger.Debug(`[MASS DELETE] Deleting feed #%d for user #%d (%d GoRoutines)`, feedID, userID, runtime.NumGoroutine())
deleteUserEntries(db, userID, feedID)
db.Exec(`DELETE FROM feeds WHERE id=$1`, feedID)
results <- true
}
}
numJobs := len(feedIDs)
jobs := make(chan int64, numJobs)
results := make(chan bool, numJobs)
2020-12-23 00:02:10 -05:00
for w := 0; w < 2; w++ {
go worker(jobs, results)
}
for j := 0; j < numJobs; j++ {
jobs <- feedIDs[j]
}
close(jobs)
for a := 1; a <= numJobs; a++ {
<-results
}
}
func deleteUserEntries(db *sql.DB, userID int64, feedID int64) {
2020-12-23 00:02:10 -05:00
rows, err := db.Query(`SELECT id FROM entries WHERE user_id=$1 AND feed_id=$2`, userID, feedID)
if err != nil {
logger.Error(`store: unable to get user feed entries: %v`, err)
return
}
defer rows.Close()
for rows.Next() {
var entryID int64
rows.Scan(&entryID)
2020-12-23 00:02:10 -05:00
logger.Debug(`[MASS DELETE] Deleting entry #%d for user #%d (%d GoRoutines)`, entryID, userID, runtime.NumGoroutine())
2020-12-23 00:02:10 -05:00
db.Exec(`DELETE FROM enclosures WHERE entry_id=$1 AND user_id=$2`, entryID, userID)
db.Exec(`DELETE FROM entries WHERE id=$1 AND user_id=$2`, entryID, userID)
}
}