ngn/website
1
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Packages Activity

restructure the API and update the admin script

Browse Source
This commit is contained in:
ngn
2025-01-04 00:00:10 +03:00
parent 03586da8df
commit 26e8909998
34 changed files with 1699 additions and 983 deletions
Download Patch File Download Diff File Expand all files Collapse all files

173
api/routes/admin.go
View File

@ -1,183 +1,154 @@
package routes
import (
"database/sql"
"net/http"
"strings"
"fmt"
"time"
"github.com/gofiber/fiber/v2"
"github.com/mattn/go-sqlite3"
"github.com/ngn13/website/api/config"
"github.com/ngn13/website/api/database"
"github.com/ngn13/website/api/status"
"github.com/ngn13/website/api/util"
)
var Token string = util.CreateToken()
func admin_log(c *fiber.Ctx, m string) error {
return c.Locals("database").(*database.Type).AdminLogAdd(&database.AdminLog{
Action: m, // action that the admin peformed
Time: time.Now().Unix(), // current time
})
}
func AuthMiddleware(c *fiber.Ctx) error {
if c.Path() == "/admin/login" {
return c.Next()
}
conf := c.Locals("config").(*config.Type)
if c.Get("Authorization") != Token {
if c.Get("Authorization") != conf.GetStr("password") {
return util.ErrAuth(c)
}
return c.Next()
}
func GET_Login(c *fiber.Ctx) error {
if c.Query("pass") != config.Get("password") {
return util.ErrAuth(c)
}
util.Info("new login from %s", util.GetIP(c))
return c.Status(http.StatusOK).JSON(fiber.Map{
"error": "",
"token": Token,
})
}
func GET_Logout(c *fiber.Ctx) error {
Token = util.CreateToken()
util.Info("logout from %s", util.GetIP(c))
return c.Status(http.StatusOK).JSON(fiber.Map{
"error": "",
})
}
func DEL_RemoveService(c *fiber.Ctx) error {
func GET_AdminLogs(c *fiber.Ctx) error {
var (
db *sql.DB
service database.Service
name string
found bool
err error
list []database.AdminLog
log database.AdminLog
)
db = *(c.Locals("database").(**sql.DB))
name = c.Query("name")
db := c.Locals("database").(*database.Type)
if name == "" {
util.ErrBadData(c)
for db.AdminLogNext(&log) {
list = append(list, log)
}
if found, err = service.Get(db, name); err != nil {
util.Fail("error while searching for a service (\"%s\"): %s", name, err.Error())
return util.ErrServer(c)
return util.JSON(c, 200, fiber.Map{
"result": list,
})
}
func DEL_DelService(c *fiber.Ctx) error {
var (
name string
err error
)
db := c.Locals("database").(*database.Type)
if name = c.Query("name"); name == "" {
util.ErrBadReq(c)
}
if !found {
return util.ErrEntryNotExists(c)
if err = admin_log(c, fmt.Sprintf("Removed service \"%s\"", name)); err != nil {
return util.ErrInternal(c, err)
}
if err = service.Remove(db); err != nil {
util.Fail("error while removing a service (\"%s\"): %s", service.Name, err.Error())
return util.ErrServer(c)
if err = db.ServiceRemove(name); err != nil {
return util.ErrInternal(c, err)
}
return util.NoError(c)
return util.JSON(c, 200, nil)
}
func PUT_AddService(c *fiber.Ctx) error {
var (
service database.Service
db *sql.DB
found bool
err error
)
db = *(c.Locals("database").(**sql.DB))
db := c.Locals("database").(*database.Type)
if c.BodyParser(&service) != nil {
return util.ErrBadJSON(c)
}
if service.Name == "" || service.Desc == "" || service.Url == "" {
return util.ErrBadData(c)
if !service.IsValid() {
return util.ErrBadReq(c)
}
if found, err = service.Get(db, service.Name); err != nil {
util.Fail("error while searching for a service (\"%s\"): %s", service.Name, err.Error())
return util.ErrServer(c)
if err = admin_log(c, fmt.Sprintf("Added service \"%s\"", service.Name)); err != nil {
return util.ErrInternal(c, err)
}
if found {
return util.ErrEntryExists(c)
if err = db.ServiceUpdate(&service); err != nil {
return util.ErrInternal(c, err)
}
if err = service.Save(db); err != nil {
util.Fail("error while saving a new service (\"%s\"): %s", service.Name, err.Error())
return util.ErrServer(c)
}
// force a status check so we can get the status of the new service
c.Locals("status").(*status.Type).Check()
return util.NoError(c)
return util.JSON(c, 200, nil)
}
func DEL_RemovePost(c *fiber.Ctx) error {
func GET_CheckService(c *fiber.Ctx) error {
c.Locals("status").(*status.Type).Check()
return util.JSON(c, 200, nil)
}
func DEL_DelNews(c *fiber.Ctx) error {
var (
db *sql.DB
id string
found bool
err error
post database.Post
id string
err error
)
db = *(c.Locals("database").(**sql.DB))
db := c.Locals("database").(*database.Type)
if id = c.Query("id"); id == "" {
return util.ErrBadData(c)
util.ErrBadReq(c)
}
if found, err = post.Get(db, id); err != nil {
util.Fail("error while searching for a post (\"%s\"): %s", id, err.Error())
return util.ErrServer(c)
if err = admin_log(c, fmt.Sprintf("Removed news \"%s\"", id)); err != nil {
return util.ErrInternal(c, err)
}
if !found {
return util.ErrEntryNotExists(c)
if err = db.NewsRemove(id); err != nil {
return util.ErrInternal(c, err)
}
if err = post.Remove(db); err != nil {
util.Fail("error while removing a post (\"%s\"): %s", post.ID, err.Error())
return util.ErrServer(c)
}
return util.NoError(c)
return util.JSON(c, 200, nil)
}
func PUT_AddPost(c *fiber.Ctx) error {
func PUT_AddNews(c *fiber.Ctx) error {
var (
db *sql.DB
post database.Post
news database.News
err error
)
db = *(c.Locals("database").(**sql.DB))
post.Public = 1
db := c.Locals("database").(*database.Type)
if c.BodyParser(&post) != nil {
if c.BodyParser(&news) != nil {
return util.ErrBadJSON(c)
}
if post.Title == "" || post.Author == "" || post.Content == "" {
return util.ErrBadData(c)
if !news.IsValid() {
return util.ErrBadReq(c)
}
post.Date = time.Now().Format("02/01/06")
if err = post.Save(db); err != nil && strings.Contains(err.Error(), sqlite3.ErrConstraintUnique.Error()) {
return util.ErrEntryExists(c)
if err = admin_log(c, fmt.Sprintf("Added news \"%s\"", news.ID)); err != nil {
return util.ErrInternal(c, err)
}
if err != nil {
util.Fail("error while saving a new post (\"%s\"): %s", post.ID, err.Error())
return util.ErrServer(c)
if err = db.NewsAdd(&news); err != nil {
return util.ErrInternal(c, err)
}
return util.NoError(c)
return util.JSON(c, 200, nil)
}

203
api/routes/blog.go
View File

@ -1,203 +0,0 @@
package routes
import (
"database/sql"
"fmt"
"net/url"
"path"
"strings"
"time"
"github.com/gofiber/fiber/v2"
"github.com/gorilla/feeds"
"github.com/ngn13/website/api/config"
"github.com/ngn13/website/api/database"
"github.com/ngn13/website/api/util"
)
func GET_Post(c *fiber.Ctx) error {
var (
post database.Post
id string
db *sql.DB
found bool
err error
)
db = *(c.Locals("database").(**sql.DB))
if id = c.Query("id"); id == "" {
return util.ErrBadData(c)
}
if found, err = post.Get(db, id); err != nil {
util.Fail("error while search for a post (\"%s\"): %s", id, err.Error())
return util.ErrServer(c)
}
if !found {
return util.ErrEntryNotExists(c)
}
return c.JSON(fiber.Map{
"error": "",
"result": post,
})
}
func GET_PostSum(c *fiber.Ctx) error {
var (
posts []database.Post
rows *sql.Rows
db *sql.DB
err error
)
db = *(c.Locals("database").(**sql.DB))
if rows, err = db.Query("SELECT * FROM posts"); err != nil {
util.Fail("cannot load posts: %s", err.Error())
return util.ErrServer(c)
}
defer rows.Close()
for rows.Next() {
var post database.Post
if err = post.Load(rows); err != nil {
util.Fail("error while loading post: %s", err.Error())
return util.ErrServer(c)
}
if post.Public == 0 {
continue
}
if len(post.Content) > 255 {
post.Content = post.Content[0:250]
}
posts = append(posts, post)
}
return c.JSON(fiber.Map{
"error": "",
"result": posts,
})
}
func getFeed(db *sql.DB) (*feeds.Feed, error) {
var (
posts []database.Post
err error
)
rows, err := db.Query("SELECT * FROM posts")
if err != nil {
return nil, err
}
for rows.Next() {
var post database.Post
if err = post.Load(rows); err != nil {
return nil, err
}
if post.Public == 0 {
continue
}
posts = append(posts, post)
}
rows.Close()
blogurl, err := url.JoinPath(
config.Get("frontend_url"), "/blog",
)
if err != nil {
return nil, fmt.Errorf("failed to create the blog URL: %s", err.Error())
}
feed := &feeds.Feed{
Title: "[ngn.tf] | blog",
Link: &feeds.Link{Href: blogurl},
Description: "ngn's personal blog",
Author: &feeds.Author{Name: "ngn", Email: "ngn@ngn.tf"},
Created: time.Now(),
}
feed.Items = []*feeds.Item{}
for _, p := range posts {
purl, err := url.JoinPath(blogurl, p.ID)
if err != nil {
return nil, fmt.Errorf("failed to create URL for '%s': %s\n", p.ID, err.Error())
}
parsed, err := time.Parse("02/01/06", p.Date)
if err != nil {
return nil, fmt.Errorf("failed to parse time for '%s': %s\n", p.ID, err.Error())
}
feed.Items = append(feed.Items, &feeds.Item{
Id: p.ID,
Title: p.Title,
Link: &feeds.Link{Href: purl},
Author: &feeds.Author{Name: p.Author},
Created: parsed,
})
}
return feed, nil
}
func GET_Feed(c *fiber.Ctx) error {
var (
db *sql.DB
err error
feed *feeds.Feed
name []string
res string
ext string
)
db = *(c.Locals("database").(**sql.DB))
if name = strings.Split(path.Base(c.Path()), "."); len(name) != 2 {
return util.ErrNotFound(c)
}
ext = name[1]
if feed, err = getFeed(db); err != nil {
util.Fail("cannot obtain the feed: %s", err.Error())
return util.ErrServer(c)
}
switch ext {
case "atom":
res, err = feed.ToAtom()
c.Set("Content-Type", "application/atom+xml")
break
case "json":
res, err = feed.ToJSON()
c.Set("Content-Type", "application/feed+json")
break
case "rss":
res, err = feed.ToRss()
c.Set("Content-Type", "application/rss+xml")
break
default:
return util.ErrNotFound(c)
}
if err != nil {
util.Fail("cannot obtain the feed as the specified format: %s", err.Error())
return util.ErrServer(c)
}
return c.Send([]byte(res))
}

32
api/routes/index.go Normal file
View File

@ -0,0 +1,32 @@
package routes
import (
"github.com/gofiber/fiber/v2"
"github.com/ngn13/website/api/config"
"github.com/ngn13/website/api/util"
)
func GET_Index(c *fiber.Ctx) error {
var (
md []byte
err error
)
conf := c.Locals("config").(*config.Type)
if !conf.GetBool("index") {
return util.ErrNotFound(c)
}
frontend := conf.GetURL("frontend_url")
api := conf.GetURL("api_url")
if md, err = util.Render("views/index.md", fiber.Map{
"frontend": frontend,
"api": api,
}); err != nil {
return util.ErrInternal(c, err)
}
return util.Markdown(c, md)
}

47
api/routes/news.go Normal file
View File

@ -0,0 +1,47 @@
package routes
import (
"strings"
"github.com/gofiber/fiber/v2"
"github.com/ngn13/website/api/config"
"github.com/ngn13/website/api/database"
"github.com/ngn13/website/api/util"
)
func GET_News(c *fiber.Ctx) error {
var (
news []database.News
n database.News
feed []byte
err error
)
db := c.Locals("database").(*database.Type)
conf := c.Locals("config").(*config.Type)
frontend := conf.GetURL("frontend_url")
lang := c.Params("lang")
if lang == "" || len(lang) != 2 {
return util.ErrBadReq(c)
}
lang = strings.ToLower(lang)
for db.NewsNext(&n) {
if n.Supports(lang) {
news = append(news, n)
}
}
if feed, err = util.Render("views/news.xml", fiber.Map{
"frontend": frontend,
"lang": lang,
"news": news,
}); err != nil {
return util.ErrInternal(c, err)
}
c.Set("Content-Type", "application/atom+xml; charset=utf-8")
return c.Send(feed)
}

35
api/routes/services.go
View File

@ -1,8 +1,6 @@
package routes
import (
"database/sql"
"github.com/gofiber/fiber/v2"
"github.com/ngn13/website/api/database"
"github.com/ngn13/website/api/util"
@ -11,32 +9,29 @@ import (
func GET_Services(c *fiber.Ctx) error {
var (
services []database.Service
rows *sql.Rows
db *sql.DB
err error
service database.Service
)
db = *(c.Locals("database").(**sql.DB))
db := c.Locals("database").(*database.Type)
name := c.Query("name")
if rows, err = db.Query("SELECT * FROM services"); err != nil {
util.Fail("cannot load services: %s", err.Error())
return util.ErrServer(c)
}
defer rows.Close()
for rows.Next() {
var service database.Service
if err = service.Load(rows); err != nil {
util.Fail("error while loading service: %s", err.Error())
return util.ErrServer(c)
if name != "" {
if s, err := db.ServiceFind(name); err != nil {
return util.ErrInternal(c, err)
} else if s != nil {
return util.JSON(c, 200, fiber.Map{
"result": s,
})
}
return util.ErrNotExist(c)
}
for db.ServiceNext(&service) {
services = append(services, service)
}
return c.JSON(fiber.Map{
"error": "",
return util.JSON(c, 200, fiber.Map{
"result": services,
})
}

139
api/routes/vote.go
View File

@ -1,139 +0,0 @@
package routes
import (
"database/sql"
"github.com/gofiber/fiber/v2"
"github.com/ngn13/website/api/database"
"github.com/ngn13/website/api/util"
)
func getVoteHash(id string, ip string) string {
return util.GetSHA512(id + "_" + ip)
}
func GET_VoteGet(c *fiber.Ctx) error {
var (
db *sql.DB
id string
hash string
vote database.Vote
found bool
err error
)
db = *(c.Locals("database").(**sql.DB))
if id = c.Query("id"); id == "" {
return util.ErrBadData(c)
}
hash = getVoteHash(id, util.GetIP(c))
if found, err = vote.Get(db, hash); err != nil {
util.Fail("error while searchig for a vote (\"%s\"): %s", hash, err.Error())
return util.ErrServer(c)
}
if !found {
return util.ErrEntryNotExists(c)
}
if vote.IsUpvote {
return c.JSON(fiber.Map{
"error": "",
"result": "upvote",
})
}
return c.JSON(fiber.Map{
"error": "",
"result": "downvote",
})
}
func GET_VoteSet(c *fiber.Ctx) error {
var (
db *sql.DB
id string
is_upvote bool
hash string
vote database.Vote
post database.Post
found bool
err error
)
db = *(c.Locals("database").(**sql.DB))
id = c.Query("id")
if c.Query("to") == "" || id == "" {
return util.ErrBadData(c)
}
if found, err = post.Get(db, id); err != nil {
util.Fail("error while searching for a post (\"%s\"): %s", id, err.Error())
return util.ErrServer(c)
}
if !found {
return util.ErrEntryNotExists(c)
}
is_upvote = c.Query("to") == "upvote"
hash = getVoteHash(id, util.GetIP(c))
if found, err = vote.Get(db, hash); err != nil {
util.Fail("error while searching for a vote (\"%s\"): %s", hash, err.Error())
return util.ErrServer(c)
}
if found {
if vote.IsUpvote == is_upvote {
return util.ErrEntryExists(c)
}
if vote.IsUpvote && !is_upvote {
post.Vote -= 2
}
if !vote.IsUpvote && is_upvote {
post.Vote += 2
}
vote.IsUpvote = is_upvote
if err = post.Update(db); err != nil {
util.Fail("error while updating post (\"%s\"): %s", post.ID, err.Error())
return util.ErrServer(c)
}
if err = vote.Update(db); err != nil {
util.Fail("error while updating vote (\"%s\"): %s", vote.Hash, err.Error())
return util.ErrServer(c)
}
return util.NoError(c)
}
vote.Hash = hash
vote.IsUpvote = is_upvote
if is_upvote {
post.Vote++
} else {
post.Vote--
}
if err = post.Update(db); err != nil {
util.Fail("error while updating post (\"%s\"): %s", post.ID, err.Error())
return util.ErrServer(c)
}
if err = vote.Save(db); err != nil {
util.Fail("error while updating vote (\"%s\"): %s", vote.Hash, err.Error())
return util.ErrServer(c)
}
return util.NoError(c)
}