559 lines
13 KiB
Go
559 lines
13 KiB
Go
package owl
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"fmt"
|
|
"net/url"
|
|
"os"
|
|
"path"
|
|
"sort"
|
|
"time"
|
|
|
|
"golang.org/x/crypto/bcrypt"
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
type User struct {
|
|
repo *Repository
|
|
name string
|
|
}
|
|
|
|
type UserConfig struct {
|
|
Title string `yaml:"title"`
|
|
SubTitle string `yaml:"subtitle"`
|
|
HeaderColor string `yaml:"header_color"`
|
|
AuthorName string `yaml:"author_name"`
|
|
Me []UserMe `yaml:"me"`
|
|
PassworHash string `yaml:"password_hash"`
|
|
Lists []PostList `yaml:"lists"`
|
|
PrimaryListInclude []string `yaml:"primary_list_include"`
|
|
HeaderMenu []MenuItem `yaml:"header_menu"`
|
|
FooterMenu []MenuItem `yaml:"footer_menu"`
|
|
}
|
|
|
|
type PostList struct {
|
|
Id string `yaml:"id"`
|
|
Title string `yaml:"title"`
|
|
Include []string `yaml:"include"`
|
|
}
|
|
|
|
type MenuItem struct {
|
|
Title string `yaml:"title"`
|
|
List string `yaml:"list"`
|
|
Url string `yaml:"url"`
|
|
Post string `yaml:"post"`
|
|
}
|
|
|
|
func (l *PostList) ContainsType(t string) bool {
|
|
for _, t2 := range l.Include {
|
|
if t2 == t {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
type UserMe struct {
|
|
Name string `yaml:"name"`
|
|
Url string `yaml:"url"`
|
|
}
|
|
|
|
type AuthCode struct {
|
|
Code string `yaml:"code"`
|
|
ClientId string `yaml:"client_id"`
|
|
RedirectUri string `yaml:"redirect_uri"`
|
|
CodeChallenge string `yaml:"code_challenge"`
|
|
CodeChallengeMethod string `yaml:"code_challenge_method"`
|
|
Scope string `yaml:"scope"`
|
|
Created time.Time `yaml:"created"`
|
|
}
|
|
|
|
type AccessToken struct {
|
|
Token string `yaml:"token"`
|
|
Scope string `yaml:"scope"`
|
|
ClientId string `yaml:"client_id"`
|
|
RedirectUri string `yaml:"redirect_uri"`
|
|
Created time.Time `yaml:"created"`
|
|
ExpiresIn int `yaml:"expires_in"`
|
|
}
|
|
|
|
type Session struct {
|
|
Id string `yaml:"id"`
|
|
Created time.Time `yaml:"created"`
|
|
ExpiresIn int `yaml:"expires_in"`
|
|
}
|
|
|
|
func (user User) Dir() string {
|
|
return path.Join(user.repo.UsersDir(), user.name)
|
|
}
|
|
|
|
func (user User) UrlPath() string {
|
|
return user.repo.UserUrlPath(user)
|
|
}
|
|
|
|
func (user User) ListUrl(list PostList) string {
|
|
url, _ := url.JoinPath(user.UrlPath(), "lists/"+list.Id+"/")
|
|
return url
|
|
}
|
|
|
|
func (user User) FullUrl() string {
|
|
url, _ := url.JoinPath(user.repo.FullUrl(), user.UrlPath())
|
|
return url
|
|
}
|
|
|
|
func (user User) AuthUrl() string {
|
|
if user.Config().PassworHash == "" {
|
|
return ""
|
|
}
|
|
url, _ := url.JoinPath(user.FullUrl(), "auth/")
|
|
return url
|
|
}
|
|
|
|
func (user User) TokenUrl() string {
|
|
url, _ := url.JoinPath(user.AuthUrl(), "token/")
|
|
return url
|
|
}
|
|
|
|
func (user User) IndieauthMetadataUrl() string {
|
|
url, _ := url.JoinPath(user.FullUrl(), ".well-known/oauth-authorization-server")
|
|
return url
|
|
}
|
|
|
|
func (user User) WebmentionUrl() string {
|
|
url, _ := url.JoinPath(user.FullUrl(), "webmention/")
|
|
return url
|
|
}
|
|
|
|
func (user User) MicropubUrl() string {
|
|
url, _ := url.JoinPath(user.FullUrl(), "micropub/")
|
|
return url
|
|
}
|
|
|
|
func (user User) MediaUrl() string {
|
|
url, _ := url.JoinPath(user.UrlPath(), "media")
|
|
return url
|
|
}
|
|
|
|
func (user User) EditorUrl() string {
|
|
url, _ := url.JoinPath(user.UrlPath(), "editor/")
|
|
return url
|
|
}
|
|
|
|
func (user User) EditorLoginUrl() string {
|
|
url, _ := url.JoinPath(user.UrlPath(), "editor/auth/")
|
|
return url
|
|
}
|
|
|
|
func (user User) PostDir() string {
|
|
return path.Join(user.Dir(), "public")
|
|
}
|
|
|
|
func (user User) MetaDir() string {
|
|
return path.Join(user.Dir(), "meta")
|
|
}
|
|
|
|
func (user User) MediaDir() string {
|
|
return path.Join(user.Dir(), "media")
|
|
}
|
|
|
|
func (user User) ConfigFile() string {
|
|
return path.Join(user.MetaDir(), "config.yml")
|
|
}
|
|
|
|
func (user User) AuthCodesFile() string {
|
|
return path.Join(user.MetaDir(), "auth_codes.yml")
|
|
}
|
|
|
|
func (user User) AccessTokensFile() string {
|
|
return path.Join(user.MetaDir(), "access_tokens.yml")
|
|
}
|
|
|
|
func (user User) SessionsFile() string {
|
|
return path.Join(user.MetaDir(), "sessions.yml")
|
|
}
|
|
|
|
func (user User) Name() string {
|
|
return user.name
|
|
}
|
|
|
|
func (user User) AvatarUrl() string {
|
|
for _, ext := range []string{".jpg", ".jpeg", ".png", ".gif"} {
|
|
if fileExists(path.Join(user.MediaDir(), "avatar"+ext)) {
|
|
url, _ := url.JoinPath(user.MediaUrl(), "avatar"+ext)
|
|
return url
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (user User) FaviconUrl() string {
|
|
for _, ext := range []string{".jpg", ".jpeg", ".png", ".gif", ".ico"} {
|
|
if fileExists(path.Join(user.MediaDir(), "favicon"+ext)) {
|
|
url, _ := url.JoinPath(user.MediaUrl(), "favicon"+ext)
|
|
return url
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (user User) AllPosts() ([]Post, error) {
|
|
postFiles := listDir(path.Join(user.Dir(), "public"))
|
|
posts := make([]Post, 0)
|
|
for _, id := range postFiles {
|
|
// if is a directory and has index.md, add to posts
|
|
if dirExists(path.Join(user.Dir(), "public", id)) {
|
|
if fileExists(path.Join(user.Dir(), "public", id, "index.md")) {
|
|
post, _ := user.GetPost(id)
|
|
posts = append(posts, post)
|
|
}
|
|
}
|
|
}
|
|
|
|
type PostWithDate struct {
|
|
post Post
|
|
date time.Time
|
|
}
|
|
|
|
postDates := make([]PostWithDate, len(posts))
|
|
for i, post := range posts {
|
|
meta := post.Meta()
|
|
postDates[i] = PostWithDate{post: post, date: meta.Date}
|
|
}
|
|
|
|
// sort posts by date
|
|
sort.Slice(postDates, func(i, j int) bool {
|
|
return postDates[i].date.After(postDates[j].date)
|
|
})
|
|
|
|
for i, post := range postDates {
|
|
posts[i] = post.post
|
|
}
|
|
|
|
return posts, nil
|
|
}
|
|
|
|
func (user User) PublishedPosts() ([]Post, error) {
|
|
posts, _ := user.AllPosts()
|
|
|
|
// remove drafts
|
|
n := 0
|
|
for _, post := range posts {
|
|
meta := post.Meta()
|
|
if !meta.Draft {
|
|
posts[n] = post
|
|
n++
|
|
}
|
|
}
|
|
posts = posts[:n]
|
|
return posts, nil
|
|
}
|
|
|
|
func (user User) PrimaryFeedPosts() ([]Post, error) {
|
|
config := user.Config()
|
|
include := config.PrimaryListInclude
|
|
if len(include) == 0 {
|
|
include = []string{"article", "reply"} // default before addition of this option
|
|
}
|
|
return user.GetPostsOfList(PostList{
|
|
Id: "",
|
|
Title: "",
|
|
Include: include,
|
|
})
|
|
}
|
|
|
|
func (user User) GetPostsOfList(list PostList) ([]Post, error) {
|
|
posts, _ := user.PublishedPosts()
|
|
|
|
// remove posts not included
|
|
n := 0
|
|
for _, post := range posts {
|
|
meta := post.Meta()
|
|
if list.ContainsType(meta.Type) {
|
|
posts[n] = post
|
|
n++
|
|
}
|
|
}
|
|
posts = posts[:n]
|
|
return posts, nil
|
|
}
|
|
|
|
func (user User) GetPost(id string) (Post, error) {
|
|
// check if posts index.md exists
|
|
if !fileExists(path.Join(user.Dir(), "public", id, "index.md")) {
|
|
return &GenericPost{}, fmt.Errorf("post %s does not exist", id)
|
|
}
|
|
|
|
post := GenericPost{user: &user, id: id}
|
|
switch post.Meta().Type {
|
|
case "article":
|
|
return &Article{GenericPost: post}, nil
|
|
case "note":
|
|
return &Note{GenericPost: post}, nil
|
|
case "reply":
|
|
return &Reply{GenericPost: post}, nil
|
|
case "bookmark":
|
|
return &Bookmark{GenericPost: post}, nil
|
|
case "page":
|
|
return &Page{GenericPost: post}, nil
|
|
}
|
|
return &post, nil
|
|
}
|
|
|
|
func (user User) CreateNewPost(meta PostMeta, content string) (Post, error) {
|
|
slugHint := meta.Title
|
|
if slugHint == "" {
|
|
slugHint = "note"
|
|
}
|
|
folder_name := toDirectoryName(slugHint)
|
|
post_dir := path.Join(user.Dir(), "public", folder_name)
|
|
|
|
// if post already exists, add -n to the end of the name
|
|
i := 0
|
|
for {
|
|
if dirExists(post_dir) {
|
|
i++
|
|
folder_name = toDirectoryName(fmt.Sprintf("%s-%d", slugHint, i))
|
|
post_dir = path.Join(user.Dir(), "public", folder_name)
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
post := GenericPost{user: &user, id: folder_name}
|
|
|
|
// if date is not set, set it to now
|
|
if meta.Date.IsZero() {
|
|
meta.Date = time.Now()
|
|
}
|
|
|
|
initial_content := ""
|
|
initial_content += "---\n"
|
|
// write meta
|
|
meta_bytes, err := yaml.Marshal(meta)
|
|
if err != nil {
|
|
return &GenericPost{}, err
|
|
}
|
|
initial_content += string(meta_bytes)
|
|
initial_content += "---\n"
|
|
initial_content += "\n"
|
|
initial_content += content
|
|
|
|
// create post file
|
|
os.Mkdir(post_dir, 0755)
|
|
os.WriteFile(post.ContentFile(), []byte(initial_content), 0644)
|
|
// create media dir
|
|
os.Mkdir(post.MediaDir(), 0755)
|
|
return user.GetPost(post.Id())
|
|
}
|
|
|
|
func (user User) Template() (string, error) {
|
|
// load base.html
|
|
path := path.Join(user.Dir(), "meta", "base.html")
|
|
base_html, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(base_html), nil
|
|
}
|
|
|
|
func (user User) Config() UserConfig {
|
|
meta := UserConfig{}
|
|
loadFromYaml(user.ConfigFile(), &meta)
|
|
return meta
|
|
}
|
|
|
|
func (user User) SetConfig(new_config UserConfig) error {
|
|
return saveToYaml(user.ConfigFile(), new_config)
|
|
}
|
|
|
|
func (user User) PostAliases() (map[string]Post, error) {
|
|
post_aliases := make(map[string]Post)
|
|
posts, err := user.PublishedPosts()
|
|
if err != nil {
|
|
return post_aliases, err
|
|
}
|
|
for _, post := range posts {
|
|
if err != nil {
|
|
return post_aliases, err
|
|
}
|
|
for _, alias := range post.Aliases() {
|
|
post_aliases[alias] = post
|
|
}
|
|
}
|
|
return post_aliases, nil
|
|
}
|
|
|
|
func (user User) GetPostList(id string) (*PostList, error) {
|
|
lists := user.Config().Lists
|
|
|
|
for _, list := range lists {
|
|
if list.Id == id {
|
|
return &list, nil
|
|
}
|
|
}
|
|
|
|
return &PostList{}, fmt.Errorf("list %s does not exist", id)
|
|
}
|
|
|
|
func (user User) AddPostList(list PostList) error {
|
|
config := user.Config()
|
|
config.Lists = append(config.Lists, list)
|
|
return user.SetConfig(config)
|
|
}
|
|
|
|
func (user User) AddHeaderMenuItem(link MenuItem) error {
|
|
config := user.Config()
|
|
config.HeaderMenu = append(config.HeaderMenu, link)
|
|
return user.SetConfig(config)
|
|
}
|
|
|
|
func (user User) AddFooterMenuItem(link MenuItem) error {
|
|
config := user.Config()
|
|
config.FooterMenu = append(config.FooterMenu, link)
|
|
return user.SetConfig(config)
|
|
}
|
|
|
|
func (user User) ResetPassword(password string) error {
|
|
bytes, err := bcrypt.GenerateFromPassword([]byte(password), 10)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
config := user.Config()
|
|
config.PassworHash = string(bytes)
|
|
return user.SetConfig(config)
|
|
}
|
|
|
|
func (user User) VerifyPassword(password string) bool {
|
|
err := bcrypt.CompareHashAndPassword(
|
|
[]byte(user.Config().PassworHash), []byte(password),
|
|
)
|
|
return err == nil
|
|
}
|
|
|
|
func (user User) getAuthCodes() []AuthCode {
|
|
codes := make([]AuthCode, 0)
|
|
loadFromYaml(user.AuthCodesFile(), &codes)
|
|
return codes
|
|
}
|
|
|
|
func (user User) addAuthCode(code AuthCode) error {
|
|
codes := user.getAuthCodes()
|
|
codes = append(codes, code)
|
|
return saveToYaml(user.AuthCodesFile(), codes)
|
|
}
|
|
|
|
func (user User) GenerateAuthCode(
|
|
client_id string, redirect_uri string,
|
|
code_challenge string, code_challenge_method string,
|
|
scope string,
|
|
) (string, error) {
|
|
// generate code
|
|
code := GenerateRandomString(32)
|
|
return code, user.addAuthCode(AuthCode{
|
|
Code: code,
|
|
ClientId: client_id,
|
|
RedirectUri: redirect_uri,
|
|
CodeChallenge: code_challenge,
|
|
CodeChallengeMethod: code_challenge_method,
|
|
Scope: scope,
|
|
Created: time.Now(),
|
|
})
|
|
}
|
|
|
|
func (user User) VerifyAuthCode(
|
|
code string, client_id string, redirect_uri string, code_verifier string,
|
|
) (bool, AuthCode) {
|
|
codes := user.getAuthCodes()
|
|
for _, c := range codes {
|
|
if c.Code == code && c.ClientId == client_id && c.RedirectUri == redirect_uri {
|
|
if c.CodeChallengeMethod == "plain" {
|
|
return c.CodeChallenge == code_verifier, c
|
|
} else if c.CodeChallengeMethod == "S256" {
|
|
// hash code_verifier
|
|
hash := sha256.Sum256([]byte(code_verifier))
|
|
return c.CodeChallenge == base64.RawURLEncoding.EncodeToString(hash[:]), c
|
|
} else if c.CodeChallengeMethod == "" {
|
|
// Check age of code
|
|
// A maximum lifetime of 10 minutes is recommended ( https://indieauth.spec.indieweb.org/#authorization-response)
|
|
if time.Since(c.Created) < 10*time.Minute {
|
|
return true, c
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false, AuthCode{}
|
|
}
|
|
|
|
func (user User) getAccessTokens() []AccessToken {
|
|
codes := make([]AccessToken, 0)
|
|
loadFromYaml(user.AccessTokensFile(), &codes)
|
|
return codes
|
|
}
|
|
|
|
func (user User) addAccessToken(code AccessToken) error {
|
|
codes := user.getAccessTokens()
|
|
codes = append(codes, code)
|
|
return saveToYaml(user.AccessTokensFile(), codes)
|
|
}
|
|
|
|
func (user User) GenerateAccessToken(authCode AuthCode) (string, int, error) {
|
|
// generate code
|
|
token := GenerateRandomString(32)
|
|
duration := 24 * 60 * 60
|
|
return token, duration, user.addAccessToken(AccessToken{
|
|
Token: token,
|
|
ClientId: authCode.ClientId,
|
|
RedirectUri: authCode.RedirectUri,
|
|
Scope: authCode.Scope,
|
|
ExpiresIn: duration,
|
|
Created: time.Now(),
|
|
})
|
|
}
|
|
|
|
func (user User) ValidateAccessToken(token string) (bool, AccessToken) {
|
|
tokens := user.getAccessTokens()
|
|
for _, t := range tokens {
|
|
if t.Token == token {
|
|
if time.Since(t.Created) < time.Duration(t.ExpiresIn)*time.Second {
|
|
return true, t
|
|
}
|
|
}
|
|
}
|
|
return false, AccessToken{}
|
|
}
|
|
|
|
func (user User) getSessions() []Session {
|
|
sessions := make([]Session, 0)
|
|
loadFromYaml(user.SessionsFile(), &sessions)
|
|
return sessions
|
|
}
|
|
|
|
func (user User) addSession(session Session) error {
|
|
sessions := user.getSessions()
|
|
sessions = append(sessions, session)
|
|
return saveToYaml(user.SessionsFile(), sessions)
|
|
}
|
|
|
|
func (user User) CreateNewSession() string {
|
|
// generate code
|
|
code := GenerateRandomString(32)
|
|
user.addSession(Session{
|
|
Id: code,
|
|
Created: time.Now(),
|
|
ExpiresIn: 30 * 24 * 60 * 60,
|
|
})
|
|
return code
|
|
}
|
|
|
|
func (user User) ValidateSession(session_id string) bool {
|
|
sessions := user.getSessions()
|
|
for _, session := range sessions {
|
|
if session.Id == session_id {
|
|
if time.Since(session.Created) < time.Duration(session.ExpiresIn)*time.Second {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|