2023-06-30 19:41:35 +00:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"context"
|
|
|
|
_ "embed"
|
|
|
|
"encoding/json"
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
|
|
|
"html/template"
|
|
|
|
"io"
|
|
|
|
"net/http"
|
|
|
|
"net/url"
|
2023-07-02 21:29:35 +00:00
|
|
|
"os"
|
2023-06-30 19:41:35 +00:00
|
|
|
"regexp"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
|
|
|
|
|
|
|
"github.com/dustin/go-humanize"
|
|
|
|
"github.com/julienschmidt/httprouter"
|
2023-07-05 15:22:46 +00:00
|
|
|
"github.com/k3a/html2text"
|
2023-06-30 19:41:35 +00:00
|
|
|
"github.com/rystaf/go-lemmy"
|
|
|
|
"github.com/rystaf/go-lemmy/types"
|
|
|
|
"golang.org/x/text/language"
|
|
|
|
"golang.org/x/text/message"
|
|
|
|
)
|
|
|
|
|
|
|
|
var funcMap = template.FuncMap{
|
2023-07-02 21:29:35 +00:00
|
|
|
"host": func(host string) string {
|
|
|
|
if l := os.Getenv("LEMMY_DOMAIN"); l != "" {
|
|
|
|
return l
|
|
|
|
}
|
|
|
|
return host
|
|
|
|
},
|
2023-07-16 00:59:32 +00:00
|
|
|
"localize": func(s string) string {
|
2023-06-30 19:41:35 +00:00
|
|
|
u, err := url.Parse(s)
|
|
|
|
if err != nil {
|
|
|
|
return s
|
|
|
|
}
|
2023-07-16 00:59:32 +00:00
|
|
|
return "." + u.Path + "@" + u.Host
|
2023-06-30 19:41:35 +00:00
|
|
|
},
|
|
|
|
"printer": func(n any) string {
|
|
|
|
p := message.NewPrinter(language.English)
|
|
|
|
return p.Sprintf("%d", n)
|
|
|
|
},
|
|
|
|
"likedPerc": func(c types.PostAggregates) string {
|
|
|
|
return fmt.Sprintf("%.1f", (float64(c.Upvotes)/float64(c.Upvotes+c.Downvotes))*100)
|
|
|
|
},
|
|
|
|
"fullname": func(person types.PersonSafe) string {
|
|
|
|
if person.Local {
|
|
|
|
return person.Name
|
|
|
|
}
|
|
|
|
l, err := url.Parse(person.ActorID)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
return person.Name
|
|
|
|
}
|
|
|
|
return person.Name + "@" + l.Host
|
|
|
|
},
|
|
|
|
"fullcname": func(c types.CommunitySafe) string {
|
|
|
|
if c.Local {
|
|
|
|
return c.Name
|
|
|
|
}
|
|
|
|
l, err := url.Parse(c.ActorID)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
return c.Name
|
|
|
|
}
|
|
|
|
return c.Name + "@" + l.Host
|
|
|
|
},
|
|
|
|
"isMod": func(c *types.GetCommunityResponse, username string) bool {
|
|
|
|
for _, mod := range c.Moderators {
|
|
|
|
if mod.Moderator.Local && username == mod.Moderator.Name {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
},
|
2023-07-02 21:29:35 +00:00
|
|
|
"domain": func(p Post) string {
|
2023-06-30 19:41:35 +00:00
|
|
|
if p.Post.URL.IsValid() {
|
|
|
|
l, err := url.Parse(p.Post.URL.String())
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return l.Host
|
|
|
|
}
|
|
|
|
if p.Post.Local {
|
|
|
|
return "self." + p.Community.Name
|
|
|
|
}
|
|
|
|
l, err := url.Parse(p.Post.ApID)
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return l.Host
|
|
|
|
},
|
|
|
|
"membership": func(s types.SubscribedType) string {
|
|
|
|
switch s {
|
|
|
|
case types.SubscribedTypeSubscribed:
|
|
|
|
return "leave"
|
|
|
|
case types.SubscribedTypeNotSubscribed:
|
|
|
|
return "join"
|
|
|
|
case types.SubscribedTypePending:
|
|
|
|
return "pending"
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
},
|
|
|
|
"isImage": func(url string) bool {
|
|
|
|
ext := url[len(url)-4:]
|
|
|
|
if ext == "jpeg" || ext == ".jpg" || ext == ".png" || ext == "webp" || ext == ".gif" {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
},
|
2023-07-07 17:42:57 +00:00
|
|
|
"thumbnail": func(p types.Post) string {
|
|
|
|
if p.ThumbnailURL.IsValid() {
|
|
|
|
return p.ThumbnailURL.String() + "?format=jpg&thumbnail=96"
|
|
|
|
}
|
2023-07-07 17:57:01 +00:00
|
|
|
re := regexp.MustCompile(`\/pictrs\/image\/([a-z0-9\-]+)\.([a-z]+)$`)
|
|
|
|
if re.MatchString(p.URL.String()) {
|
|
|
|
return p.URL.String() + "?format=jpg&thumbnail=96"
|
|
|
|
}
|
2023-07-15 15:12:10 +00:00
|
|
|
re = regexp.MustCompile(`^https:\/\/(i\.)?imgur.com\/([a-zA-Z0-9]{5,})(\.[a-zA-Z0-9]+)?`)
|
2023-07-07 17:42:57 +00:00
|
|
|
if re.MatchString(p.URL.String()) {
|
2023-07-15 15:12:10 +00:00
|
|
|
return re.ReplaceAllString(p.URL.String(), "https://i.imgur.com/${2}s.jpg")
|
2023-07-07 17:57:01 +00:00
|
|
|
}
|
|
|
|
if p.URL.IsValid() {
|
2023-07-07 17:42:57 +00:00
|
|
|
return "/_/static/link.png"
|
|
|
|
}
|
|
|
|
return "/_/static/text.png"
|
|
|
|
},
|
2023-06-30 19:41:35 +00:00
|
|
|
"humanize": humanize.Time,
|
|
|
|
"markdown": func(host string, body string) template.HTML {
|
|
|
|
var buf bytes.Buffer
|
2023-07-07 16:25:40 +00:00
|
|
|
re := regexp.MustCompile(`\s---\s`)
|
|
|
|
body = re.ReplaceAllString(body, "\n***\n")
|
2023-07-24 03:19:49 +00:00
|
|
|
// community bangs
|
2023-07-24 04:24:29 +00:00
|
|
|
body = RegReplace(body, `([^\[])!([a-zA-Z0-9_]+)@([a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]+)+)`, `$1[!$2@$3](/c/$2@$3)`)
|
2023-06-30 19:41:35 +00:00
|
|
|
if err := md.Convert([]byte(body), &buf); err != nil {
|
2023-07-05 15:22:46 +00:00
|
|
|
fmt.Println(err)
|
|
|
|
return template.HTML(body)
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
2023-07-16 00:59:32 +00:00
|
|
|
body = buf.String()
|
|
|
|
body = strings.Replace(body, `<img `, `<img loading="lazy" `, -1)
|
|
|
|
body = LemmyLinkRewrite(body, host, os.Getenv("LEMMY_DOMAIN"))
|
2023-07-16 17:45:40 +00:00
|
|
|
body = RegReplace(body, `::: ?spoiler (.*?)\n([\S\s]*?):::`, "<details><summary>$1</summary>$2</details>")
|
2023-07-16 00:59:32 +00:00
|
|
|
return template.HTML(body)
|
2023-06-30 19:41:35 +00:00
|
|
|
},
|
2023-07-05 15:22:46 +00:00
|
|
|
"rmmarkdown": func(body string) string {
|
|
|
|
var buf bytes.Buffer
|
|
|
|
if err := md.Convert([]byte(body), &buf); err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
return body
|
|
|
|
}
|
|
|
|
text := html2text.HTML2TextWithOptions(buf.String(), html2text.WithLinksInnerText())
|
|
|
|
re := regexp.MustCompile(`\<https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)\>`)
|
|
|
|
return re.ReplaceAllString(text, "")
|
|
|
|
},
|
2023-06-30 19:41:35 +00:00
|
|
|
"contains": strings.Contains,
|
2023-07-01 02:42:45 +00:00
|
|
|
"sub": func(a int32, b int) int {
|
2023-06-30 19:41:35 +00:00
|
|
|
return int(a) - b
|
|
|
|
},
|
2023-07-13 22:24:03 +00:00
|
|
|
"add": func(a int32, b int) int {
|
|
|
|
return int(a) + b
|
|
|
|
},
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
|
2023-07-16 00:59:32 +00:00
|
|
|
func LemmyLinkRewrite(input string, host string, lemmy_domain string) (body string) {
|
|
|
|
body = input
|
|
|
|
// localize community and user links
|
2023-07-26 21:02:19 +00:00
|
|
|
body = RegReplace(body, `href="https:\/\/([a-zA-Z0-9\.\-]+)\/((c|u|comment|post)\/[^#\?]*?)"`, `href="/$2@$1"`)
|
2023-07-16 00:59:32 +00:00
|
|
|
// remove extra instance tag
|
2023-07-16 02:41:39 +00:00
|
|
|
body = RegReplace(body, `href="(https:\/)?(\/[a-zA-Z0-9\.\-]+)?\/((c|u)\/[a-zA-Z0-9]+@[a-zA-Z0-9\.\-]+)@([a-zA-Z0-9\.\-]+)"`, `href="/$3"`)
|
2023-07-16 00:59:32 +00:00
|
|
|
if lemmy_domain == "" {
|
|
|
|
// add domain to relative links
|
2023-07-16 13:00:49 +00:00
|
|
|
body = RegReplace(body, `href="\/((c|u|post|comment)\/(.*?)")`, `href="/`+host+`/$1`)
|
2023-07-16 00:59:32 +00:00
|
|
|
// convert links to relative
|
2023-07-16 13:00:49 +00:00
|
|
|
body = RegReplace(body, `href="https:\/\/([a-zA-Z0-9\.\-]+\/((c|u|post|comment)\/[a-zA-Z0-9]+"))`, `href="/$1`)
|
2023-07-16 00:59:32 +00:00
|
|
|
} else {
|
|
|
|
// convert local links to relative
|
2023-07-16 13:00:49 +00:00
|
|
|
body = RegReplace(body, `href="https:\/\/`+lemmy_domain+`\/(c\/[a-zA-Z0-9]+"|(c|u|post|comment)\/(.*?)")`, `href="/$1`)
|
2023-07-16 00:59:32 +00:00
|
|
|
body = RegReplace(body, `href="(.*)@`+lemmy_domain+`"`, `href="$1"`)
|
|
|
|
}
|
2023-07-24 03:07:57 +00:00
|
|
|
|
|
|
|
re := regexp.MustCompile(`href="\/?([a-zA-Z0-9\.\-]*)\/(c|u|post|comment)\/(.*?)@(.*?)"`)
|
|
|
|
// assume "old." subdomain is mlmym and remove
|
2023-07-16 00:59:32 +00:00
|
|
|
matches := re.FindAllStringSubmatch(body, -1)
|
2023-07-24 03:07:57 +00:00
|
|
|
for _, match := range matches {
|
|
|
|
if match[4][0:4] == "old." {
|
|
|
|
s := 1
|
|
|
|
if match[1] == "" {
|
|
|
|
s += 1
|
|
|
|
}
|
|
|
|
body = strings.Replace(body, match[0], `href="/`+strings.Join(match[s:4], "/")+"@"+match[4][4:]+`"`, -1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// remove redundant instance tag
|
|
|
|
matches = re.FindAllStringSubmatch(body, -1)
|
2023-07-16 00:59:32 +00:00
|
|
|
for _, match := range matches {
|
|
|
|
if match[1] == match[4] {
|
|
|
|
body = strings.Replace(body, match[0], `href="/`+strings.Join(match[1:4], "/")+`"`, -1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return body
|
|
|
|
}
|
|
|
|
|
|
|
|
func RegReplace(input string, match string, replace string) string {
|
|
|
|
re := regexp.MustCompile(match)
|
|
|
|
return re.ReplaceAllString(input, replace)
|
|
|
|
}
|
|
|
|
|
2023-06-30 19:41:35 +00:00
|
|
|
func Initialize(Host string, r *http.Request) (State, error) {
|
|
|
|
state := State{
|
2023-07-23 22:19:53 +00:00
|
|
|
Host: Host,
|
|
|
|
Page: 1,
|
|
|
|
Status: http.StatusOK,
|
|
|
|
Version: version,
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
2023-07-26 20:53:06 +00:00
|
|
|
if watch != nil {
|
|
|
|
state.Watch = *watch
|
|
|
|
}
|
2023-07-02 21:29:35 +00:00
|
|
|
lemmyDomain := os.Getenv("LEMMY_DOMAIN")
|
|
|
|
if lemmyDomain != "" {
|
|
|
|
state.Host = "."
|
|
|
|
Host = lemmyDomain
|
|
|
|
}
|
2023-07-01 02:10:24 +00:00
|
|
|
remoteAddr := r.RemoteAddr
|
|
|
|
if r.Header.Get("CF-Connecting-IP") != "" {
|
|
|
|
remoteAddr = r.Header.Get("CF-Connecting-IP")
|
|
|
|
}
|
|
|
|
client := http.Client{Transport: NewAddHeaderTransport(remoteAddr)}
|
2023-07-02 21:29:35 +00:00
|
|
|
c, err := lemmy.NewWithClient("https://"+Host, &client)
|
2023-06-30 19:41:35 +00:00
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
state.Status = http.StatusInternalServerError
|
|
|
|
return state, err
|
|
|
|
}
|
|
|
|
state.HTTPClient = &client
|
|
|
|
state.Client = c
|
2023-07-02 21:29:35 +00:00
|
|
|
token := getCookie(r, "jwt")
|
|
|
|
user := getCookie(r, "user")
|
|
|
|
parts := strings.Split(user, ":")
|
2023-07-10 15:53:15 +00:00
|
|
|
if len(parts) == 2 && token != "" {
|
2023-07-02 21:29:35 +00:00
|
|
|
if id, err := strconv.Atoi(parts[1]); err == nil {
|
2023-06-30 19:41:35 +00:00
|
|
|
state.Client.Token = token
|
|
|
|
sess := Session{
|
2023-07-02 21:29:35 +00:00
|
|
|
UserName: parts[0],
|
|
|
|
UserID: id,
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
state.Session = &sess
|
|
|
|
}
|
|
|
|
}
|
2023-07-02 21:29:35 +00:00
|
|
|
state.Listing = getCookie(r, "DefaultListingType")
|
|
|
|
state.Sort = getCookie(r, "DefaultSortType")
|
2023-07-14 13:55:42 +00:00
|
|
|
state.CommentSort = getCookie(r, "DefaultCommentSortType")
|
2023-07-03 00:11:13 +00:00
|
|
|
state.Dark = getCookie(r, "Dark") != ""
|
2023-07-05 13:49:41 +00:00
|
|
|
state.ShowNSFW = getCookie(r, "ShowNSFW") != ""
|
2023-07-14 13:55:42 +00:00
|
|
|
state.HideInstanceNames = getCookie(r, "HideInstanceNames") != ""
|
2023-07-02 21:29:35 +00:00
|
|
|
state.ParseQuery(r.URL.RawQuery)
|
|
|
|
if state.Sort == "" {
|
|
|
|
state.Sort = "Hot"
|
|
|
|
}
|
2023-07-14 13:55:42 +00:00
|
|
|
if state.CommentSort == "" {
|
|
|
|
state.CommentSort = "Hot"
|
|
|
|
}
|
2023-07-02 21:29:35 +00:00
|
|
|
if state.Listing == "" || state.Session == nil && state.Listing == "Subscribed" {
|
2023-06-30 19:41:35 +00:00
|
|
|
state.Listing = "All"
|
|
|
|
}
|
|
|
|
return state, nil
|
|
|
|
}
|
|
|
|
func GetTemplate(name string) (*template.Template, error) {
|
|
|
|
if *watch {
|
|
|
|
t := template.New(name).Funcs(funcMap)
|
|
|
|
glob, err := t.ParseGlob("templates/*")
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return glob, nil
|
|
|
|
}
|
|
|
|
t, ok := templates[name]
|
|
|
|
if !ok {
|
|
|
|
return nil, errors.New("template not found")
|
|
|
|
}
|
|
|
|
return t, nil
|
|
|
|
}
|
|
|
|
func Render(w http.ResponseWriter, templateName string, state State) {
|
|
|
|
tmpl, err := GetTemplate(templateName)
|
|
|
|
if err != nil {
|
|
|
|
w.Write([]byte("500 - Server Error"))
|
2023-07-03 01:50:03 +00:00
|
|
|
fmt.Println(err)
|
2023-06-30 19:41:35 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
if len(state.TopCommunities) == 0 {
|
|
|
|
state.GetCommunities()
|
|
|
|
}
|
|
|
|
if state.Session != nil {
|
|
|
|
state.GetUnreadCount()
|
|
|
|
}
|
|
|
|
if state.Status != http.StatusOK {
|
|
|
|
w.WriteHeader(state.Status)
|
|
|
|
}
|
2023-07-10 15:53:15 +00:00
|
|
|
header := w.Header()
|
|
|
|
header.Set("Content-Security-Policy", "script-src 'self'")
|
2023-06-30 19:41:35 +00:00
|
|
|
err = tmpl.Execute(w, state)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println("execute fail", err)
|
|
|
|
w.Write([]byte("500 - Server Error"))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func GetRoot(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
data := make(map[string]any)
|
2023-07-06 18:57:48 +00:00
|
|
|
data["Title"] = r.Host
|
2023-06-30 19:41:35 +00:00
|
|
|
tmpl, err := GetTemplate("root.html")
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println("execute fail", err)
|
|
|
|
w.Write([]byte("500 - Server Error"))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
tmpl.Execute(w, data)
|
|
|
|
}
|
|
|
|
|
|
|
|
type NodeSoftware struct {
|
|
|
|
Name string `json:"name"`
|
|
|
|
Version string `json:"version"`
|
|
|
|
}
|
|
|
|
type NodeInfo struct {
|
|
|
|
Software NodeSoftware `json:"software"`
|
|
|
|
}
|
|
|
|
|
2023-07-01 14:57:04 +00:00
|
|
|
func IsLemmy(domain string, remoteAddr string) bool {
|
|
|
|
client := http.Client{Transport: NewAddHeaderTransport(remoteAddr)}
|
2023-06-30 19:41:35 +00:00
|
|
|
var nodeInfo NodeInfo
|
2023-07-01 14:57:04 +00:00
|
|
|
res, err := client.Get("https://" + domain + "/nodeinfo/2.0.json")
|
2023-06-30 19:41:35 +00:00
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
err = json.NewDecoder(res.Body).Decode(&nodeInfo)
|
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
if nodeInfo.Software.Name == "lemmy" {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func PostRoot(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
data := make(map[string]any)
|
|
|
|
tmpl, err := GetTemplate("root.html")
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println("execute fail", err)
|
|
|
|
w.Write([]byte("500 - Server Error"))
|
|
|
|
return
|
|
|
|
}
|
2023-07-01 02:10:24 +00:00
|
|
|
input := r.FormValue("destination")
|
2023-06-30 19:41:35 +00:00
|
|
|
re := regexp.MustCompile(`^(([a-zA-Z]{1})|([a-zA-Z]{1}[a-zA-Z]{1})|([a-zA-Z]{1}[0-9]{1})|([0-9]{1}[a-zA-Z]{1})|([a-zA-Z0-9][a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]))\.([a-zA-Z]{2,6}|[a-zA-Z0-9-]{2,30}\.[a-zA-Z
|
2023-07-01 02:10:24 +00:00
|
|
|
]{2,3})`)
|
|
|
|
if re.MatchString(input) {
|
|
|
|
input = "https://" + input
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
2023-07-01 02:10:24 +00:00
|
|
|
dest, err := url.Parse(input)
|
2023-07-01 14:57:04 +00:00
|
|
|
if dest.Host != "" {
|
|
|
|
state, _ := Initialize(dest.Host, r)
|
|
|
|
if err := state.LemmyError(dest.Host); err != nil {
|
|
|
|
data["Error"] = err
|
|
|
|
} else {
|
|
|
|
redirectUrl := "/" + dest.Host + dest.Path
|
|
|
|
if dest.RawQuery != "" {
|
|
|
|
redirectUrl = redirectUrl + "?" + dest.RawQuery
|
|
|
|
}
|
|
|
|
http.Redirect(w, r, redirectUrl, 302)
|
|
|
|
return
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
2023-07-01 14:57:04 +00:00
|
|
|
} else {
|
|
|
|
data["Error"] = "Invalid destination"
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
tmpl.Execute(w, data)
|
|
|
|
}
|
|
|
|
func GetIcon(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
if ps.ByName("host") == "favicon.ico" {
|
|
|
|
w.WriteHeader(http.StatusNotFound)
|
|
|
|
w.Write([]byte("404 - Not Found"))
|
|
|
|
}
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
state.Client.Token = ""
|
|
|
|
resp, err := state.Client.Site(context.Background(), types.GetSite{})
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
|
|
w.Write([]byte("500 - Server Error"))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if !resp.SiteView.Site.Icon.IsValid() {
|
|
|
|
w.WriteHeader(http.StatusNotFound)
|
|
|
|
w.Write([]byte("404 - Not Found"))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
iresp, err := state.HTTPClient.Get(resp.SiteView.Site.Icon.String())
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
|
|
w.Write([]byte("500 - Server Error"))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
defer iresp.Body.Close()
|
|
|
|
w.Header().Set("Content-Type", "image/jpeg")
|
|
|
|
w.Header().Set("Cache-Control", "max-age=2592000")
|
|
|
|
io.Copy(w, iresp.Body)
|
|
|
|
return
|
|
|
|
|
|
|
|
}
|
|
|
|
func GetFrontpage(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
m, _ := url.ParseQuery(r.URL.RawQuery)
|
|
|
|
if len(m["edit"]) > 0 {
|
|
|
|
state.Op = "edit_community"
|
|
|
|
}
|
|
|
|
if ps.ByName("community") == "" || state.Op == "edit_community" {
|
|
|
|
state.GetSite()
|
|
|
|
}
|
|
|
|
state.GetCommunity(ps.ByName("community"))
|
|
|
|
if state.Op == "" {
|
|
|
|
state.GetPosts()
|
|
|
|
}
|
2023-07-05 22:34:46 +00:00
|
|
|
if state.XHR {
|
|
|
|
Render(w, "xhr.html", state)
|
|
|
|
} else {
|
|
|
|
Render(w, "frontpage.html", state)
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
|
2023-07-23 17:53:02 +00:00
|
|
|
func GetCommunities(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
r.URL.Path = "/search"
|
2023-07-23 19:18:14 +00:00
|
|
|
if ps.ByName("host") != "" {
|
|
|
|
r.URL.Path = "/" + ps.ByName("host") + "/search"
|
|
|
|
}
|
|
|
|
r.URL.RawQuery = "searchtype=Communities&sort=TopMonth"
|
2023-07-23 17:53:02 +00:00
|
|
|
http.Redirect(w, r, r.URL.String(), 301)
|
|
|
|
}
|
|
|
|
|
2023-07-16 13:00:49 +00:00
|
|
|
func ResolveId(r *http.Request, class string, id string, host string) string {
|
|
|
|
remoteAddr := r.RemoteAddr
|
|
|
|
if r.Header.Get("CF-Connecting-IP") != "" {
|
|
|
|
remoteAddr = r.Header.Get("CF-Connecting-IP")
|
|
|
|
}
|
|
|
|
client := http.Client{Transport: NewAddHeaderTransport(remoteAddr)}
|
|
|
|
c, err := lemmy.NewWithClient("https://"+host, &client)
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
idn, _ := strconv.Atoi(id)
|
|
|
|
if class == "post" {
|
|
|
|
resp, err := c.Post(context.Background(), types.GetPost{
|
|
|
|
ID: types.NewOptional(idn),
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return resp.PostView.Post.ApID
|
|
|
|
}
|
|
|
|
resp, err := c.Comment(context.Background(), types.GetComment{
|
|
|
|
ID: idn,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return resp.CommentView.Comment.ApID
|
|
|
|
}
|
|
|
|
|
2023-06-30 19:41:35 +00:00
|
|
|
func GetPost(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
2023-07-16 13:00:49 +00:00
|
|
|
if path := strings.Split(ps.ByName("postid"), "@"); len(path) > 1 {
|
|
|
|
apid := ResolveId(r, "post", path[0], path[1])
|
|
|
|
if apid != "" {
|
|
|
|
resp, err := state.Client.ResolveObject(context.Background(), types.ResolveObject{
|
|
|
|
Q: apid,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
dest := apid
|
|
|
|
if os.Getenv("LEMMY_DOMAIN") == "" {
|
|
|
|
dest = RegReplace(dest, `https:\/\/([a-zA-Z0-9\.\-]+\/post\/\d+)`, `/$1`)
|
|
|
|
}
|
|
|
|
http.Redirect(w, r, dest, 302)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
post, _ := resp.Post.Value()
|
|
|
|
if post.Post.ID > 0 {
|
|
|
|
dest := RegReplace(r.URL.String(), `(([a-zA-Z0-9\.\-]+)?/post/)([a-zA-Z0-9\-\.@]+)`, `$1`)
|
|
|
|
dest += strconv.Itoa(post.Post.ID)
|
|
|
|
http.Redirect(w, r, dest, 302)
|
|
|
|
return
|
|
|
|
} else {
|
|
|
|
http.Redirect(w, r, apid, 302)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
m, _ := url.ParseQuery(r.URL.RawQuery)
|
|
|
|
if len(m["edit"]) > 0 {
|
|
|
|
state.Op = "edit_post"
|
|
|
|
state.GetSite()
|
|
|
|
}
|
2023-07-27 01:07:39 +00:00
|
|
|
if len(m["content"]) > 0 {
|
|
|
|
state.Content = m["content"][0]
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
postid, _ := strconv.Atoi(ps.ByName("postid"))
|
|
|
|
state.GetPost(postid)
|
|
|
|
state.GetComments()
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
}
|
|
|
|
func GetComment(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
2023-07-16 13:00:49 +00:00
|
|
|
if path := strings.Split(ps.ByName("commentid"), "@"); len(path) > 1 {
|
|
|
|
apid := ResolveId(r, "comment", path[0], path[1])
|
|
|
|
if apid != "" {
|
|
|
|
resp, err := state.Client.ResolveObject(context.Background(), types.ResolveObject{
|
|
|
|
Q: apid,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
dest := apid
|
|
|
|
if os.Getenv("LEMMY_DOMAIN") == "" {
|
|
|
|
dest = RegReplace(dest, `https:\/\/([a-zA-Z0-9\.\-]+\/comment\/\d+)`, `/$1`)
|
|
|
|
}
|
|
|
|
http.Redirect(w, r, dest, 302)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
comment, _ := resp.Comment.Value()
|
|
|
|
if comment.Comment.ID > 0 {
|
|
|
|
dest := RegReplace(r.URL.String(), `(([a-zA-Z0-9\.\-]+)?/comment/)([a-zA-Z0-9\-\.@]+)`, `$1`)
|
|
|
|
dest += strconv.Itoa(comment.Comment.ID)
|
|
|
|
http.Redirect(w, r, dest, 302)
|
|
|
|
return
|
|
|
|
} else {
|
|
|
|
http.Redirect(w, r, apid, 302)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
m, _ := url.ParseQuery(r.URL.RawQuery)
|
|
|
|
if len(m["reply"]) > 0 {
|
|
|
|
state.Op = "reply"
|
|
|
|
}
|
|
|
|
if len(m["edit"]) > 0 {
|
|
|
|
state.Op = "edit"
|
|
|
|
}
|
2023-07-27 01:07:39 +00:00
|
|
|
if r.Method == "POST" && len(m["content"]) > 0 {
|
|
|
|
state.Content = m["content"][0]
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
if len(m["source"]) > 0 {
|
|
|
|
state.Op = "source"
|
|
|
|
}
|
2023-07-13 13:45:51 +00:00
|
|
|
if len(m["context"]) > 0 {
|
|
|
|
ctx, _ := strconv.Atoi(m["context"][0])
|
|
|
|
state.Context = ctx
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
commentid, _ := strconv.Atoi(ps.ByName("commentid"))
|
|
|
|
state.GetComment(commentid)
|
2023-07-27 01:07:39 +00:00
|
|
|
if state.XHR && len(m["content"]) > 0 {
|
|
|
|
Render(w, "create_comment.html", state)
|
|
|
|
return
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
state.GetPost(state.PostID)
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
}
|
|
|
|
func GetUser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
state.GetUser(ps.ByName("username"))
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
}
|
|
|
|
func GetMessageForm(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
state.Op = "send_message"
|
|
|
|
state.GetUser(ps.ByName("username"))
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
}
|
|
|
|
func SendMessage(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
userid, _ := strconv.Atoi(r.FormValue("userid"))
|
|
|
|
_, err = state.Client.CreatePrivateMessage(context.Background(), types.CreatePrivateMessage{
|
|
|
|
Content: r.FormValue("content"),
|
|
|
|
RecipientID: userid,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
r.URL.Path = "/" + state.Host + "/inbox"
|
|
|
|
http.Redirect(w, r, r.URL.String(), 301)
|
|
|
|
}
|
|
|
|
func GetCreatePost(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
state.GetSite()
|
|
|
|
state.GetCommunity("")
|
|
|
|
state.Op = "create_post"
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
}
|
|
|
|
func GetCreateCommunity(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
2023-07-02 21:29:35 +00:00
|
|
|
fmt.Println(err)
|
2023-06-30 19:41:35 +00:00
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
state.GetSite()
|
|
|
|
state.Op = "create_community"
|
2023-07-02 21:29:35 +00:00
|
|
|
if ps.ByName("community") != "" {
|
|
|
|
state.GetCommunity(ps.ByName("community"))
|
|
|
|
state.Op = "edit_community"
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
Render(w, "index.html", state)
|
|
|
|
}
|
|
|
|
|
|
|
|
func Inbox(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
state.GetMessages()
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
state.MarkAllAsRead()
|
|
|
|
}
|
2023-07-02 21:29:35 +00:00
|
|
|
func getCookie(r *http.Request, name string) string {
|
|
|
|
cookie, err := r.Cookie(name)
|
|
|
|
if err != nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
return cookie.Value
|
|
|
|
}
|
2023-07-03 01:06:39 +00:00
|
|
|
func setCookie(w http.ResponseWriter, host string, name string, value string) {
|
|
|
|
if host == "." {
|
|
|
|
host = ""
|
|
|
|
}
|
2023-07-02 21:29:35 +00:00
|
|
|
cookie := http.Cookie{
|
2023-07-10 15:53:15 +00:00
|
|
|
Name: name,
|
|
|
|
Value: value,
|
|
|
|
MaxAge: 86400 * 30,
|
|
|
|
HttpOnly: true,
|
|
|
|
SameSite: http.SameSiteNoneMode,
|
|
|
|
Secure: true,
|
|
|
|
Path: "/" + host,
|
2023-07-02 21:29:35 +00:00
|
|
|
}
|
|
|
|
http.SetCookie(w, &cookie)
|
|
|
|
}
|
2023-07-03 01:06:39 +00:00
|
|
|
func deleteCookie(w http.ResponseWriter, host string, name string) {
|
|
|
|
if host == "." {
|
|
|
|
host = ""
|
|
|
|
}
|
2023-07-02 21:29:35 +00:00
|
|
|
cookie := http.Cookie{
|
|
|
|
Name: name,
|
2023-07-03 01:06:39 +00:00
|
|
|
Path: "/" + host,
|
2023-07-02 21:29:35 +00:00
|
|
|
MaxAge: -1,
|
|
|
|
}
|
|
|
|
http.SetCookie(w, &cookie)
|
|
|
|
}
|
|
|
|
func Settings(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
2023-07-28 16:51:17 +00:00
|
|
|
state.GetSite()
|
2023-07-02 21:29:35 +00:00
|
|
|
switch r.Method {
|
|
|
|
case "POST":
|
2023-07-14 13:55:42 +00:00
|
|
|
for _, name := range []string{"DefaultSortType", "DefaultListingType", "DefaultCommentSortType"} {
|
2023-07-07 16:27:44 +00:00
|
|
|
deleteCookie(w, state.Host, name)
|
|
|
|
setCookie(w, "", name, r.FormValue(name))
|
2023-07-02 21:29:35 +00:00
|
|
|
}
|
2023-07-03 00:11:13 +00:00
|
|
|
if r.FormValue("darkmode") != "" {
|
2023-07-05 22:34:46 +00:00
|
|
|
setCookie(w, "", "Dark", "1")
|
2023-07-03 00:11:13 +00:00
|
|
|
state.Dark = true
|
|
|
|
} else {
|
2023-07-03 01:06:39 +00:00
|
|
|
deleteCookie(w, state.Host, "Dark")
|
2023-07-05 22:34:46 +00:00
|
|
|
deleteCookie(w, "", "Dark")
|
2023-07-03 00:11:13 +00:00
|
|
|
state.Dark = false
|
|
|
|
}
|
2023-07-05 13:49:41 +00:00
|
|
|
if r.FormValue("shownsfw") != "" {
|
2023-07-07 16:27:44 +00:00
|
|
|
setCookie(w, "", "ShowNSFW", "1")
|
2023-07-05 13:49:41 +00:00
|
|
|
state.ShowNSFW = true
|
|
|
|
} else {
|
|
|
|
deleteCookie(w, state.Host, "ShowNSFW")
|
2023-07-07 16:27:44 +00:00
|
|
|
deleteCookie(w, "", "ShowNSFW")
|
2023-07-05 13:49:41 +00:00
|
|
|
state.ShowNSFW = false
|
|
|
|
}
|
2023-07-14 13:55:42 +00:00
|
|
|
if r.FormValue("hideInstanceNames") != "" {
|
|
|
|
setCookie(w, "", "HideInstanceNames", "1")
|
|
|
|
state.HideInstanceNames = true
|
|
|
|
} else {
|
|
|
|
deleteCookie(w, "", "HideInstanceNames")
|
|
|
|
state.HideInstanceNames = false
|
|
|
|
}
|
2023-07-02 21:29:35 +00:00
|
|
|
state.Listing = r.FormValue("DefaultListingType")
|
|
|
|
state.Sort = r.FormValue("DefaultSortType")
|
2023-07-14 13:55:42 +00:00
|
|
|
state.CommentSort = r.FormValue("DefaultCommentSortType")
|
2023-07-05 13:49:41 +00:00
|
|
|
// TODO save user settings
|
2023-07-02 21:29:35 +00:00
|
|
|
case "GET":
|
|
|
|
if state.Session != nil {
|
2023-07-05 13:49:41 +00:00
|
|
|
// TODO fetch user settings
|
2023-07-02 21:29:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
Render(w, "settings.html", state)
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
|
|
|
|
func SignUpOrLogin(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
2023-07-04 01:53:18 +00:00
|
|
|
fmt.Println(err)
|
2023-06-30 19:41:35 +00:00
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
var token string
|
2023-07-02 21:29:35 +00:00
|
|
|
var username string
|
2023-06-30 19:41:35 +00:00
|
|
|
switch r.FormValue("submit") {
|
|
|
|
case "log in":
|
2023-07-04 01:53:18 +00:00
|
|
|
login := types.Login{
|
2023-06-30 19:41:35 +00:00
|
|
|
UsernameOrEmail: r.FormValue("username"),
|
|
|
|
Password: r.FormValue("password"),
|
2023-07-04 01:53:18 +00:00
|
|
|
}
|
|
|
|
if r.FormValue("totp") != "" {
|
|
|
|
login.Totp2faToken = types.NewOptional(r.FormValue("totp"))
|
|
|
|
}
|
|
|
|
resp, err := state.Client.Login(context.Background(), login)
|
2023-06-30 19:41:35 +00:00
|
|
|
if err != nil {
|
2023-07-04 01:53:18 +00:00
|
|
|
if strings.Contains(fmt.Sprintf("%v", err), "missing_totp_token") {
|
|
|
|
state.Op = "2fa"
|
|
|
|
}
|
|
|
|
fmt.Println(err)
|
2023-06-30 19:41:35 +00:00
|
|
|
state.Error = err
|
|
|
|
state.GetSite()
|
|
|
|
state.GetCaptcha()
|
|
|
|
Render(w, "login.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if resp.JWT.IsValid() {
|
|
|
|
token = resp.JWT.String()
|
2023-07-02 21:29:35 +00:00
|
|
|
username = r.FormValue("username")
|
2023-07-05 13:49:41 +00:00
|
|
|
deleteCookie(w, state.Host, "ShowNSFW")
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
case "sign up":
|
|
|
|
register := types.Register{
|
|
|
|
Username: r.FormValue("username"),
|
|
|
|
Password: r.FormValue("password"),
|
|
|
|
PasswordVerify: r.FormValue("passwordverify"),
|
|
|
|
ShowNSFW: r.FormValue("nsfw") != "",
|
|
|
|
}
|
|
|
|
if r.FormValue("email") != "" {
|
|
|
|
register.Email = types.NewOptional(r.FormValue("email"))
|
|
|
|
}
|
|
|
|
if r.FormValue("answer") != "" {
|
|
|
|
register.Answer = types.NewOptional(r.FormValue("answer"))
|
|
|
|
}
|
|
|
|
if r.FormValue("captchauuid") != "" {
|
|
|
|
register.CaptchaUuid = types.NewOptional(r.FormValue("captchauuid"))
|
|
|
|
}
|
|
|
|
if r.FormValue("captchaanswer") != "" {
|
|
|
|
register.CaptchaAnswer = types.NewOptional(r.FormValue("captchaanswer"))
|
|
|
|
}
|
|
|
|
resp, err := state.Client.Register(context.Background(), register)
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
state.GetSite()
|
|
|
|
state.GetCaptcha()
|
|
|
|
Render(w, "login.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if resp.JWT.IsValid() {
|
2023-07-02 21:29:35 +00:00
|
|
|
username = r.FormValue("username")
|
2023-06-30 19:41:35 +00:00
|
|
|
token = resp.JWT.String()
|
|
|
|
} else {
|
|
|
|
var alert string
|
|
|
|
if resp.RegistrationCreated {
|
|
|
|
alert = "Registration application submitted. "
|
|
|
|
}
|
|
|
|
if resp.VerifyEmailSent {
|
|
|
|
alert = alert + "Email verification sent. "
|
|
|
|
}
|
|
|
|
q := r.URL.Query()
|
|
|
|
q.Add("alert", alert)
|
|
|
|
r.URL.RawQuery = q.Encode()
|
|
|
|
http.Redirect(w, r, r.URL.String(), 301)
|
2023-07-11 14:21:57 +00:00
|
|
|
return
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if token != "" {
|
2023-07-02 21:29:35 +00:00
|
|
|
state.GetUser(username)
|
2023-07-11 14:21:57 +00:00
|
|
|
if state.User == nil {
|
|
|
|
return
|
|
|
|
}
|
2023-07-03 01:06:39 +00:00
|
|
|
setCookie(w, state.Host, "jwt", token)
|
2023-07-02 21:29:35 +00:00
|
|
|
userid := strconv.Itoa(state.User.PersonView.Person.ID)
|
2023-07-03 01:06:39 +00:00
|
|
|
setCookie(w, state.Host, "user", state.User.PersonView.Person.Name+":"+userid)
|
|
|
|
setCookie(w, state.Host, "jwt", token)
|
2023-06-30 19:41:35 +00:00
|
|
|
r.URL.Path = "/" + state.Host
|
|
|
|
http.Redirect(w, r, r.URL.String(), 301)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func GetLogin(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
state.GetSite()
|
2023-07-11 14:21:57 +00:00
|
|
|
if state.Site != nil && state.Site.SiteView.LocalSite.CaptchaEnabled {
|
2023-07-01 02:42:45 +00:00
|
|
|
state.GetCaptcha()
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
m, _ := url.ParseQuery(r.URL.RawQuery)
|
|
|
|
if len(m["alert"]) > 0 {
|
|
|
|
state.Alert = m["alert"][0]
|
|
|
|
}
|
|
|
|
Render(w, "login.html", state)
|
|
|
|
}
|
|
|
|
func Search(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if state.CommunityName != "" {
|
2023-07-03 00:11:13 +00:00
|
|
|
state.GetCommunity(state.CommunityName)
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
if state.UserName != "" {
|
|
|
|
state.GetUser(state.UserName)
|
|
|
|
} else if state.Community == nil {
|
|
|
|
state.GetSite()
|
|
|
|
}
|
|
|
|
m, _ := url.ParseQuery(r.URL.RawQuery)
|
|
|
|
state.SearchType = "Posts"
|
|
|
|
if len(m["searchtype"]) > 0 {
|
|
|
|
switch m["searchtype"][0] {
|
|
|
|
case "Comments":
|
|
|
|
state.SearchType = "Comments"
|
|
|
|
case "Communities":
|
|
|
|
state.SearchType = "Communities"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
state.Search(state.SearchType)
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
}
|
|
|
|
|
|
|
|
type PictrsFile struct {
|
|
|
|
Filename string `json:"file"`
|
|
|
|
DeleteToken string `json:"delete_token"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type PictrsResponse struct {
|
|
|
|
Message string `json:"msg"`
|
|
|
|
Files []PictrsFile `json:"files"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func UserOp(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
|
|
|
|
state, err := Initialize(ps.ByName("host"), r)
|
|
|
|
if err != nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
switch r.FormValue("op") {
|
|
|
|
case "leave":
|
|
|
|
communityid, _ := strconv.Atoi(r.FormValue("communityid"))
|
|
|
|
state.Client.FollowCommunity(context.Background(), types.FollowCommunity{
|
|
|
|
CommunityID: communityid,
|
|
|
|
Follow: false,
|
|
|
|
})
|
|
|
|
case "join":
|
|
|
|
communityid, _ := strconv.Atoi(r.FormValue("communityid"))
|
|
|
|
state.Client.FollowCommunity(context.Background(), types.FollowCommunity{
|
|
|
|
CommunityID: communityid,
|
|
|
|
Follow: true,
|
|
|
|
})
|
2023-07-15 15:12:10 +00:00
|
|
|
case "block":
|
|
|
|
communityid, _ := strconv.Atoi(r.FormValue("communityid"))
|
|
|
|
state.Client.BlockCommunity(context.Background(), types.BlockCommunity{
|
|
|
|
CommunityID: communityid,
|
|
|
|
Block: true,
|
|
|
|
})
|
|
|
|
case "unblock":
|
|
|
|
communityid, _ := strconv.Atoi(r.FormValue("communityid"))
|
|
|
|
state.Client.BlockCommunity(context.Background(), types.BlockCommunity{
|
|
|
|
CommunityID: communityid,
|
|
|
|
Block: false,
|
|
|
|
})
|
2023-06-30 19:41:35 +00:00
|
|
|
case "logout":
|
2023-07-03 01:06:39 +00:00
|
|
|
deleteCookie(w, state.Host, "jwt")
|
|
|
|
deleteCookie(w, state.Host, "user")
|
2023-06-30 19:41:35 +00:00
|
|
|
case "login":
|
2023-07-04 01:53:18 +00:00
|
|
|
login := types.Login{
|
|
|
|
UsernameOrEmail: r.FormValue("username"),
|
|
|
|
Password: r.FormValue("password"),
|
|
|
|
}
|
|
|
|
if r.FormValue("totp") != "" {
|
|
|
|
login.Totp2faToken = types.NewOptional(r.FormValue("totp"))
|
|
|
|
}
|
|
|
|
resp, err := state.Client.Login(context.Background(), login)
|
2023-06-30 19:41:35 +00:00
|
|
|
if err != nil {
|
2023-07-04 01:53:18 +00:00
|
|
|
if strings.Contains(fmt.Sprintf("%v", err), "missing_totp_token") {
|
|
|
|
state.Op = "2fa"
|
2023-07-23 19:05:31 +00:00
|
|
|
}
|
|
|
|
state.GetSite()
|
|
|
|
if state.Site != nil && state.Site.SiteView.LocalSite.CaptchaEnabled {
|
|
|
|
state.GetCaptcha()
|
2023-07-04 01:53:18 +00:00
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
state.Status = http.StatusUnauthorized
|
2023-07-23 19:05:31 +00:00
|
|
|
state.Error = err
|
|
|
|
Render(w, "login.html", state)
|
|
|
|
return
|
2023-07-04 01:53:18 +00:00
|
|
|
} else if resp.JWT.IsValid() {
|
|
|
|
state.GetUser(r.FormValue("username"))
|
|
|
|
if state.User != nil {
|
|
|
|
setCookie(w, state.Host, "jwt", resp.JWT.String())
|
|
|
|
userid := strconv.Itoa(state.User.PersonView.Person.ID)
|
|
|
|
setCookie(w, state.Host, "user", state.User.PersonView.Person.Name+":"+userid)
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
case "create_community":
|
|
|
|
state.GetSite()
|
|
|
|
community := types.CreateCommunity{
|
|
|
|
Name: r.FormValue("name"),
|
|
|
|
Title: r.FormValue("title"),
|
|
|
|
}
|
|
|
|
if r.FormValue("description") != "" {
|
|
|
|
community.Description = types.NewOptional(r.FormValue("description"))
|
|
|
|
}
|
|
|
|
if file, handler, err := r.FormFile("icon"); err == nil {
|
|
|
|
pres, err := state.UploadImage(file, handler)
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
community.Icon = types.NewOptional("https://" + state.Host + "/pictrs/image/" + pres.Files[0].Filename)
|
|
|
|
}
|
|
|
|
if file, handler, err := r.FormFile("banner"); err == nil {
|
|
|
|
pres, err := state.UploadImage(file, handler)
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
community.Banner = types.NewOptional("https://" + state.Host + "/pictrs/image/" + pres.Files[0].Filename)
|
|
|
|
}
|
|
|
|
resp, err := state.Client.CreateCommunity(context.Background(), community)
|
|
|
|
if err == nil {
|
|
|
|
r.URL.Path = "/" + state.Host + "/c/" + resp.CommunityView.Community.Name
|
|
|
|
} else {
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
|
|
|
case "edit_community":
|
|
|
|
state.CommunityName = ps.ByName("community")
|
|
|
|
state.GetCommunity("")
|
|
|
|
if state.Community == nil {
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
state.GetSite()
|
|
|
|
community := types.EditCommunity{
|
|
|
|
CommunityID: state.Community.CommunityView.Community.ID,
|
|
|
|
}
|
|
|
|
if r.FormValue("title") != "" {
|
|
|
|
community.Title = types.NewOptional(r.FormValue("title"))
|
|
|
|
}
|
|
|
|
if r.FormValue("description") != "" {
|
|
|
|
community.Description = types.NewOptional(r.FormValue("description"))
|
|
|
|
}
|
|
|
|
if file, handler, err := r.FormFile("icon"); err == nil {
|
|
|
|
pres, err := state.UploadImage(file, handler)
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
community.Icon = types.NewOptional("https://" + state.Host + "/pictrs/image/" + pres.Files[0].Filename)
|
|
|
|
}
|
|
|
|
if file, handler, err := r.FormFile("banner"); err == nil {
|
|
|
|
pres, err := state.UploadImage(file, handler)
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
community.Banner = types.NewOptional("https://" + state.Host + "/pictrs/image/" + pres.Files[0].Filename)
|
|
|
|
}
|
|
|
|
resp, err := state.Client.EditCommunity(context.Background(), community)
|
|
|
|
if err == nil {
|
|
|
|
r.URL.Path = "/" + state.Host + "/c/" + resp.CommunityView.Community.Name
|
|
|
|
} else {
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
|
|
|
case "create_post":
|
2023-07-04 02:43:16 +00:00
|
|
|
if state.CommunityName == "" {
|
|
|
|
state.CommunityName = r.FormValue("communityname")
|
|
|
|
}
|
2023-07-03 00:11:13 +00:00
|
|
|
state.GetCommunity(state.CommunityName)
|
2023-06-30 19:41:35 +00:00
|
|
|
state.GetSite()
|
|
|
|
if state.Community == nil {
|
|
|
|
state.Status = http.StatusBadRequest
|
|
|
|
state.Op = "create_post"
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
post := types.CreatePost{
|
|
|
|
Name: r.FormValue("name"),
|
|
|
|
CommunityID: state.Community.CommunityView.Community.ID,
|
|
|
|
}
|
|
|
|
if r.FormValue("url") != "" {
|
|
|
|
post.URL = types.NewOptional(r.FormValue("url"))
|
|
|
|
}
|
|
|
|
file, handler, err := r.FormFile("file")
|
|
|
|
if err == nil {
|
|
|
|
pres, err := state.UploadImage(file, handler)
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
post.URL = types.NewOptional("https://" + state.Host + "/pictrs/image/" + pres.Files[0].Filename)
|
|
|
|
}
|
|
|
|
if r.FormValue("body") != "" {
|
|
|
|
post.Body = types.NewOptional(r.FormValue("body"))
|
|
|
|
}
|
|
|
|
if r.FormValue("language") != "" {
|
|
|
|
languageid, _ := strconv.Atoi(r.FormValue("language"))
|
|
|
|
post.LanguageID = types.NewOptional(languageid)
|
|
|
|
}
|
|
|
|
resp, err := state.Client.CreatePost(context.Background(), post)
|
|
|
|
if err == nil {
|
|
|
|
postid := strconv.Itoa(resp.PostView.Post.ID)
|
|
|
|
r.URL.Path = "/" + state.Host + "/post/" + postid
|
|
|
|
} else {
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
|
|
|
case "edit_post":
|
|
|
|
r.ParseMultipartForm(10 << 20)
|
|
|
|
state.GetSite()
|
|
|
|
postid, _ := strconv.Atoi(ps.ByName("postid"))
|
|
|
|
post := types.EditPost{
|
|
|
|
PostID: postid,
|
|
|
|
Body: types.NewOptional(r.FormValue("body")),
|
2023-07-05 15:01:10 +00:00
|
|
|
Name: types.NewOptional(r.FormValue("name")),
|
2023-06-30 19:41:35 +00:00
|
|
|
URL: types.NewOptional(r.FormValue("url")),
|
|
|
|
}
|
|
|
|
if r.FormValue("url") == "" {
|
|
|
|
post.URL = types.Optional[string]{}
|
|
|
|
}
|
|
|
|
if r.FormValue("language") != "" {
|
|
|
|
languageid, _ := strconv.Atoi(r.FormValue("language"))
|
|
|
|
post.LanguageID = types.NewOptional(languageid)
|
|
|
|
}
|
|
|
|
file, handler, err := r.FormFile("file")
|
|
|
|
if err == nil {
|
|
|
|
pres, err := state.UploadImage(file, handler)
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
post.URL = types.NewOptional("https://" + state.Host + "/pictrs/image/" + pres.Files[0].Filename)
|
|
|
|
}
|
|
|
|
|
|
|
|
resp, err := state.Client.EditPost(context.Background(), post)
|
|
|
|
if err == nil {
|
|
|
|
postid := strconv.Itoa(resp.PostView.Post.ID)
|
|
|
|
r.URL.Path = "/" + state.Host + "/post/" + postid
|
|
|
|
r.URL.RawQuery = ""
|
|
|
|
} else {
|
|
|
|
state.Status = http.StatusBadRequest
|
|
|
|
state.Error = err
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
2023-07-05 14:20:07 +00:00
|
|
|
case "save_post":
|
|
|
|
postid, _ := strconv.Atoi(r.FormValue("postid"))
|
|
|
|
_, err := state.Client.SavePost(context.Background(), types.SavePost{
|
|
|
|
PostID: postid,
|
|
|
|
Save: r.FormValue("submit") == "save",
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
2023-07-12 15:23:13 +00:00
|
|
|
if r.FormValue("xhr") != "" {
|
|
|
|
state.GetPost(postid)
|
|
|
|
state.PostID = 0
|
|
|
|
state.Op = "save_post"
|
|
|
|
state.XHR = true
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
2023-07-05 14:20:07 +00:00
|
|
|
case "save_comment":
|
|
|
|
commentid, _ := strconv.Atoi(r.FormValue("commentid"))
|
|
|
|
_, err := state.Client.SaveComment(context.Background(), types.SaveComment{
|
|
|
|
CommentID: commentid,
|
|
|
|
Save: r.FormValue("submit") == "save",
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
|
|
|
if r.FormValue("xhr") != "" {
|
|
|
|
state.XHR = true
|
|
|
|
state.GetComment(commentid)
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
case "delete_post":
|
|
|
|
postid, _ := strconv.Atoi(r.FormValue("postid"))
|
|
|
|
post := types.DeletePost{
|
|
|
|
PostID: postid,
|
|
|
|
Deleted: true,
|
|
|
|
}
|
|
|
|
if r.FormValue("undo") != "" {
|
|
|
|
post.Deleted = false
|
|
|
|
}
|
|
|
|
resp, err := state.Client.DeletePost(context.Background(), post)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
} else {
|
|
|
|
r.URL.Path = "/" + state.Host + "/c/" + resp.PostView.Community.Name
|
|
|
|
r.URL.RawQuery = ""
|
|
|
|
}
|
2023-07-20 23:36:12 +00:00
|
|
|
case "read_post":
|
|
|
|
postid, _ := strconv.Atoi(r.FormValue("postid"))
|
|
|
|
post := types.MarkPostAsRead{
|
|
|
|
PostID: postid,
|
|
|
|
Read: true,
|
|
|
|
}
|
|
|
|
if r.FormValue("submit") == "mark unread" {
|
|
|
|
post.Read = false
|
|
|
|
}
|
|
|
|
_, err := state.Client.MarkPostAsRead(context.Background(), post)
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
} else if r.FormValue("xhr") != "" {
|
|
|
|
w.Write([]byte{})
|
|
|
|
return
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
case "vote_post":
|
|
|
|
var score int16
|
|
|
|
score = 1
|
|
|
|
if r.FormValue("vote") != "▲" {
|
|
|
|
score = -1
|
|
|
|
}
|
|
|
|
if r.FormValue("undo") == strconv.Itoa(int(score)) {
|
|
|
|
score = 0
|
|
|
|
}
|
|
|
|
postid, _ := strconv.Atoi(r.FormValue("postid"))
|
|
|
|
post := types.CreatePostLike{
|
|
|
|
PostID: postid,
|
|
|
|
Score: score,
|
|
|
|
}
|
|
|
|
state.Client.CreatePostLike(context.Background(), post)
|
2023-07-02 21:29:35 +00:00
|
|
|
if r.FormValue("xhr") != "" {
|
|
|
|
state.GetPost(postid)
|
2023-07-05 22:34:46 +00:00
|
|
|
state.PostID = 0
|
|
|
|
state.Op = "vote_post"
|
2023-07-02 21:29:35 +00:00
|
|
|
state.XHR = true
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
case "vote_comment":
|
|
|
|
var score int16
|
|
|
|
score = 1
|
2023-07-05 14:20:07 +00:00
|
|
|
if r.FormValue("submit") != "▲" {
|
2023-06-30 19:41:35 +00:00
|
|
|
score = -1
|
|
|
|
}
|
|
|
|
if r.FormValue("undo") == strconv.Itoa(int(score)) {
|
|
|
|
score = 0
|
|
|
|
}
|
|
|
|
commentid, _ := strconv.Atoi(r.FormValue("commentid"))
|
|
|
|
post := types.CreateCommentLike{
|
|
|
|
CommentID: commentid,
|
|
|
|
Score: score,
|
|
|
|
}
|
|
|
|
state.Client.CreateCommentLike(context.Background(), post)
|
2023-07-02 21:29:35 +00:00
|
|
|
if r.FormValue("xhr") != "" {
|
|
|
|
state.XHR = true
|
|
|
|
state.GetComment(commentid)
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
case "create_comment":
|
|
|
|
if ps.ByName("postid") != "" {
|
|
|
|
postid, _ := strconv.Atoi(ps.ByName("postid"))
|
|
|
|
state.PostID = postid
|
|
|
|
}
|
|
|
|
if r.FormValue("parentid") != "" {
|
|
|
|
parentid, _ := strconv.Atoi(r.FormValue("parentid"))
|
|
|
|
state.GetComment(parentid)
|
|
|
|
}
|
2023-07-27 01:07:39 +00:00
|
|
|
content := r.FormValue("content")
|
|
|
|
file, handler, err := r.FormFile("file")
|
|
|
|
if err == nil {
|
|
|
|
pres, err := state.UploadImage(file, handler)
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
content += ("![](https://" + state.Host + "/pictrs/image/" + pres.Files[0].Filename + ")")
|
|
|
|
}
|
2023-07-08 20:51:42 +00:00
|
|
|
if r.FormValue("submit") == "save" {
|
|
|
|
createComment := types.CreateComment{
|
2023-07-27 01:07:39 +00:00
|
|
|
Content: content,
|
2023-07-08 20:51:42 +00:00
|
|
|
PostID: state.PostID,
|
|
|
|
}
|
|
|
|
if state.CommentID > 0 {
|
|
|
|
createComment.ParentID = types.NewOptional(state.CommentID)
|
|
|
|
}
|
|
|
|
resp, err := state.Client.CreateComment(context.Background(), createComment)
|
|
|
|
if err == nil {
|
|
|
|
if r.FormValue("xhr") != "" {
|
|
|
|
state.XHR = true
|
|
|
|
state.Comments = nil
|
|
|
|
state.GetComment(resp.CommentView.Comment.ID)
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
postid := strconv.Itoa(state.PostID)
|
|
|
|
commentid := strconv.Itoa(resp.CommentView.Comment.ID)
|
|
|
|
r.URL.Path = "/" + state.Host + "/post/" + postid
|
|
|
|
r.URL.Fragment = "c" + commentid
|
|
|
|
} else {
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
2023-07-27 01:07:39 +00:00
|
|
|
} else if r.FormValue("submit") == "preview" {
|
|
|
|
q := r.URL.Query()
|
|
|
|
q.Set("content", content)
|
|
|
|
q.Set("reply", "")
|
|
|
|
if r.FormValue("xhr") != "" {
|
|
|
|
q.Set("xhr", "1")
|
|
|
|
}
|
|
|
|
r.URL.RawQuery = q.Encode()
|
|
|
|
if ps.ByName("postid") != "" {
|
|
|
|
GetPost(w, r, ps)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if ps.ByName("commentid") != "" {
|
|
|
|
GetComment(w, r, ps)
|
|
|
|
return
|
|
|
|
}
|
2023-07-08 20:51:42 +00:00
|
|
|
} else if r.FormValue("xhr") != "" {
|
|
|
|
w.Write([]byte{})
|
|
|
|
return
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
2023-07-08 20:51:42 +00:00
|
|
|
if r.FormValue("submit") == "cancel" {
|
|
|
|
r.URL.RawQuery = ""
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
case "edit_comment":
|
|
|
|
commentid, _ := strconv.Atoi(r.FormValue("commentid"))
|
2023-07-27 01:07:39 +00:00
|
|
|
q := r.URL.Query()
|
|
|
|
content := r.FormValue("content")
|
|
|
|
file, handler, err := r.FormFile("file")
|
|
|
|
if err == nil {
|
|
|
|
pres, err := state.UploadImage(file, handler)
|
|
|
|
if err != nil {
|
|
|
|
state.Error = err
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
content += ("![](https://" + state.Host + "/pictrs/image/" + pres.Files[0].Filename + ")")
|
|
|
|
}
|
|
|
|
|
2023-07-08 20:51:42 +00:00
|
|
|
if r.FormValue("submit") == "save" {
|
|
|
|
resp, err := state.Client.EditComment(context.Background(), types.EditComment{
|
|
|
|
CommentID: commentid,
|
2023-07-27 01:07:39 +00:00
|
|
|
Content: types.NewOptional(content),
|
2023-07-08 20:51:42 +00:00
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
} else {
|
|
|
|
commentid := strconv.Itoa(resp.CommentView.Comment.ID)
|
|
|
|
r.URL.Fragment = "c" + commentid
|
|
|
|
r.URL.RawQuery = ""
|
|
|
|
}
|
2023-07-27 01:07:39 +00:00
|
|
|
} else if r.FormValue("submit") == "preview" {
|
|
|
|
q.Set("content", content)
|
|
|
|
q.Set("edit", "")
|
|
|
|
if r.FormValue("xhr") != "" {
|
|
|
|
q.Set("xhr", "1")
|
|
|
|
}
|
|
|
|
r.URL.RawQuery = q.Encode()
|
|
|
|
if ps.ByName("commentid") != "" {
|
|
|
|
GetComment(w, r, ps)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
} else if r.FormValue("submit") == "cancel" {
|
|
|
|
if ps.ByName("commentid") != "" {
|
|
|
|
if r.FormValue("xhr") != "" {
|
|
|
|
q.Set("xhr", "1")
|
|
|
|
}
|
|
|
|
r.URL.RawQuery = q.Encode()
|
|
|
|
GetComment(w, r, ps)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
} else if r.FormValue("xhr") != "" {
|
|
|
|
w.Write([]byte{})
|
|
|
|
return
|
2023-07-08 20:51:42 +00:00
|
|
|
}
|
|
|
|
if r.FormValue("xhr") != "" {
|
|
|
|
state.XHR = true
|
|
|
|
state.GetComment(commentid)
|
|
|
|
Render(w, "index.html", state)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if r.FormValue("submit") == "cancel" {
|
2023-06-30 19:41:35 +00:00
|
|
|
r.URL.RawQuery = ""
|
|
|
|
}
|
|
|
|
case "delete_comment":
|
|
|
|
commentid, _ := strconv.Atoi(r.FormValue("commentid"))
|
|
|
|
resp, err := state.Client.DeleteComment(context.Background(), types.DeleteComment{
|
|
|
|
CommentID: commentid,
|
|
|
|
Deleted: true,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
} else {
|
|
|
|
commentid := strconv.Itoa(resp.CommentView.Comment.ID)
|
|
|
|
r.URL.Fragment = "c" + commentid
|
|
|
|
r.URL.RawQuery = ""
|
|
|
|
}
|
2023-07-05 13:49:41 +00:00
|
|
|
case "shownsfw":
|
|
|
|
if r.FormValue("submit") == "continue" {
|
2023-07-07 16:27:44 +00:00
|
|
|
setCookie(w, "", "ShowNSFW", "1")
|
2023-07-05 13:49:41 +00:00
|
|
|
} else {
|
|
|
|
r.URL.Path = "/" + state.Host
|
|
|
|
}
|
2023-06-30 19:41:35 +00:00
|
|
|
}
|
|
|
|
http.Redirect(w, r, r.URL.String(), 301)
|
|
|
|
}
|
2023-07-02 21:29:35 +00:00
|
|
|
func GetRouter() *httprouter.Router {
|
|
|
|
host := os.Getenv("LEMMY_DOMAIN")
|
|
|
|
router := httprouter.New()
|
|
|
|
if host == "" {
|
|
|
|
router.ServeFiles("/:host/static/*filepath", http.Dir("public"))
|
|
|
|
router.GET("/", GetRoot)
|
|
|
|
router.POST("/", PostRoot)
|
|
|
|
router.GET("/:host/", middleware(GetFrontpage))
|
|
|
|
router.GET("/:host/search", middleware(Search))
|
|
|
|
router.POST("/:host/search", middleware(UserOp))
|
|
|
|
router.GET("/:host/inbox", middleware(Inbox))
|
2023-07-08 15:26:41 +00:00
|
|
|
router.POST("/:host/inbox", middleware(UserOp))
|
2023-07-02 21:29:35 +00:00
|
|
|
router.GET("/:host/login", middleware(GetLogin))
|
|
|
|
router.POST("/:host/login", middleware(SignUpOrLogin))
|
|
|
|
router.GET("/:host/settings", middleware(Settings))
|
|
|
|
router.POST("/:host/settings", middleware(Settings))
|
|
|
|
router.POST("/:host/", middleware(UserOp))
|
|
|
|
router.GET("/:host/icon.jpg", middleware(GetIcon))
|
|
|
|
router.GET("/:host/c/:community", middleware(GetFrontpage))
|
|
|
|
router.POST("/:host/c/:community", middleware(UserOp))
|
|
|
|
router.GET("/:host/c/:community/search", middleware(Search))
|
|
|
|
router.GET("/:host/c/:community/edit", middleware(GetCreateCommunity))
|
|
|
|
router.GET("/:host/post/:postid", middleware(GetPost))
|
|
|
|
router.POST("/:host/post/:postid", middleware(UserOp))
|
|
|
|
router.GET("/:host/comment/:commentid", middleware(GetComment))
|
|
|
|
router.GET("/:host/comment/:commentid/:op", middleware(GetComment))
|
|
|
|
router.POST("/:host/comment/:commentid", middleware(UserOp))
|
|
|
|
router.GET("/:host/u/:username", middleware(GetUser))
|
|
|
|
router.GET("/:host/u/:username/message", middleware(GetMessageForm))
|
|
|
|
router.POST("/:host/u/:username/message", middleware(SendMessage))
|
|
|
|
router.POST("/:host/u/:username", middleware(UserOp))
|
|
|
|
router.GET("/:host/u/:username/search", middleware(Search))
|
|
|
|
router.GET("/:host/create_post", middleware(GetCreatePost))
|
|
|
|
router.POST("/:host/create_post", middleware(UserOp))
|
|
|
|
router.GET("/:host/create_community", middleware(GetCreateCommunity))
|
|
|
|
router.POST("/:host/create_community", middleware(UserOp))
|
2023-07-23 17:53:02 +00:00
|
|
|
router.GET("/:host/communities", middleware(GetCommunities))
|
2023-07-02 21:29:35 +00:00
|
|
|
} else {
|
|
|
|
router.ServeFiles("/_/static/*filepath", http.Dir("public"))
|
|
|
|
router.GET("/", middleware(GetFrontpage))
|
|
|
|
router.GET("/search", middleware(Search))
|
|
|
|
router.POST("/search", middleware(UserOp))
|
|
|
|
router.GET("/inbox", middleware(Inbox))
|
2023-07-08 15:26:41 +00:00
|
|
|
router.POST("/inbox", middleware(UserOp))
|
2023-07-02 21:29:35 +00:00
|
|
|
router.GET("/login", middleware(GetLogin))
|
|
|
|
router.POST("/login", middleware(SignUpOrLogin))
|
|
|
|
router.GET("/settings", middleware(Settings))
|
|
|
|
router.POST("/settings", middleware(Settings))
|
|
|
|
router.POST("/", middleware(UserOp))
|
|
|
|
router.GET("/icon.jpg", middleware(GetIcon))
|
|
|
|
router.GET("/c/:community", middleware(GetFrontpage))
|
|
|
|
router.POST("/c/:community", middleware(UserOp))
|
|
|
|
router.GET("/c/:community/search", middleware(Search))
|
|
|
|
router.GET("/c/:community/edit", middleware(GetCreateCommunity))
|
|
|
|
router.GET("/post/:postid", middleware(GetPost))
|
|
|
|
router.POST("/post/:postid", middleware(UserOp))
|
|
|
|
router.GET("/comment/:commentid", middleware(GetComment))
|
|
|
|
router.GET("/comment/:commentid/:op", middleware(GetComment))
|
|
|
|
router.POST("/comment/:commentid", middleware(UserOp))
|
|
|
|
router.GET("/u/:username", middleware(GetUser))
|
|
|
|
router.GET("/u/:username/message", middleware(GetMessageForm))
|
|
|
|
router.POST("/u/:username/message", middleware(SendMessage))
|
|
|
|
router.POST("/u/:username", middleware(UserOp))
|
|
|
|
router.GET("/u/:username/search", middleware(Search))
|
|
|
|
router.GET("/create_post", middleware(GetCreatePost))
|
|
|
|
router.POST("/create_post", middleware(UserOp))
|
|
|
|
router.GET("/create_community", middleware(GetCreateCommunity))
|
|
|
|
router.POST("/create_community", middleware(UserOp))
|
2023-07-23 17:53:02 +00:00
|
|
|
router.GET("/communities", middleware(GetCommunities))
|
2023-07-02 21:29:35 +00:00
|
|
|
}
|
|
|
|
return router
|
|
|
|
}
|