generated from templates/go-generic
454 lines
9.8 KiB
Go
454 lines
9.8 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"codeflow.dananglin.me.uk/apollo/gator/internal/database"
|
|
"codeflow.dananglin.me.uk/apollo/gator/internal/rss"
|
|
"github.com/google/uuid"
|
|
"github.com/lib/pq"
|
|
)
|
|
|
|
type commands struct {
|
|
commandMap map[string]commandFunc
|
|
}
|
|
|
|
type commandFunc func(*state, command) error
|
|
|
|
type command struct {
|
|
name string
|
|
args []string
|
|
}
|
|
|
|
func (c *commands) register(name string, f commandFunc) {
|
|
c.commandMap[name] = f
|
|
}
|
|
|
|
func (c *commands) run(s *state, cmd command) error {
|
|
runFunc, ok := c.commandMap[cmd.name]
|
|
if !ok {
|
|
return fmt.Errorf("unrecognised command: %s", cmd.name)
|
|
}
|
|
|
|
return runFunc(s, cmd)
|
|
}
|
|
|
|
func handlerLogin(s *state, cmd command) error {
|
|
if len(cmd.args) != 1 {
|
|
return fmt.Errorf("unexpected number of arguments: want 1, got %d", len(cmd.args))
|
|
}
|
|
|
|
username := cmd.args[0]
|
|
|
|
user, err := s.db.GetUserByName(context.Background(), username)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to get the user from the database: %w", err)
|
|
}
|
|
|
|
if err := s.config.SetUser(user.Name); err != nil {
|
|
return fmt.Errorf("login error: %w", err)
|
|
}
|
|
|
|
fmt.Printf("The current user is set to %q.\n", username)
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerRegister(s *state, cmd command) error {
|
|
if len(cmd.args) != 1 {
|
|
return fmt.Errorf("unexpected number of arguments: want 1, got %d", len(cmd.args))
|
|
}
|
|
|
|
name := cmd.args[0]
|
|
|
|
timestamp := time.Now()
|
|
|
|
args := database.CreateUserParams{
|
|
ID: uuid.New(),
|
|
CreatedAt: timestamp,
|
|
UpdatedAt: timestamp,
|
|
Name: name,
|
|
}
|
|
|
|
user, err := s.db.CreateUser(context.Background(), args)
|
|
if err != nil {
|
|
if uniqueViolation(err) {
|
|
return errors.New("this user is already registered")
|
|
}
|
|
|
|
return fmt.Errorf("unable to register the user: %w", err)
|
|
}
|
|
|
|
if err := s.config.SetUser(name); err != nil {
|
|
return fmt.Errorf("unable to update the configuration: %w", err)
|
|
}
|
|
|
|
fmt.Printf("Successfully registered %s.\n", user.Name)
|
|
fmt.Println("DEBUG:", user)
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerReset(s *state, _ command) error {
|
|
if err := s.db.DeleteAllUsers(context.Background()); err != nil {
|
|
fmt.Errorf("unable to delete the users from the database: %w", err)
|
|
}
|
|
|
|
fmt.Println("Successfully removed all users from the database.")
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerUsers(s *state, _ command) error {
|
|
users, err := s.db.GetAllUsers(context.Background())
|
|
if err != nil {
|
|
fmt.Errorf("unable to get the users from the database: %w", err)
|
|
}
|
|
|
|
if len(users) == 0 {
|
|
fmt.Println("There are no registered users.")
|
|
|
|
return nil
|
|
}
|
|
|
|
fmt.Printf("Registered users:\n\n")
|
|
|
|
for _, user := range users {
|
|
if user.Name == s.config.CurrentUsername {
|
|
fmt.Printf("- %s (current)\n", user.Name)
|
|
} else {
|
|
fmt.Printf("- %s\n", user.Name)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerAgg(s *state, cmd command) error {
|
|
if len(cmd.args) != 1 {
|
|
return fmt.Errorf("unexpected number of arguments: want 1, got %d", len(cmd.args))
|
|
}
|
|
|
|
intervalArg := cmd.args[0]
|
|
|
|
interval, err := time.ParseDuration(intervalArg)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to parse the interval: %w", err)
|
|
}
|
|
|
|
fmt.Printf("Fetching feeds every %s\n", interval.String())
|
|
|
|
tick := time.Tick(interval)
|
|
|
|
for range tick {
|
|
if err := scrapeFeeds(s); err != nil {
|
|
fmt.Println("ERROR: %v", err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerAddFeed(s *state, cmd command, user database.User) error {
|
|
if len(cmd.args) != 2 {
|
|
return fmt.Errorf("unexpected number of arguments: want 2, got %d", len(cmd.args))
|
|
}
|
|
|
|
name, url := cmd.args[0], cmd.args[1]
|
|
|
|
timestamp := time.Now()
|
|
|
|
createdFeedArgs := database.CreateFeedParams{
|
|
ID: uuid.New(),
|
|
CreatedAt: timestamp,
|
|
UpdatedAt: timestamp,
|
|
Name: name,
|
|
Url: url,
|
|
UserID: user.ID,
|
|
}
|
|
|
|
feed, err := s.db.CreateFeed(context.Background(), createdFeedArgs)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to add the feed: %w", err)
|
|
}
|
|
|
|
fmt.Println("Successfully added the feed.")
|
|
|
|
fmt.Println("DEBUG:", feed)
|
|
|
|
createFeedFollowArgs := database.CreateFeedFollowParams{
|
|
ID: uuid.New(),
|
|
CreatedAt: timestamp,
|
|
UpdatedAt: timestamp,
|
|
UserID: user.ID,
|
|
FeedID: feed.ID,
|
|
}
|
|
|
|
followRecord, err := s.db.CreateFeedFollow(context.Background(), createFeedFollowArgs)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to create the feed follow record in the database: %w", err)
|
|
}
|
|
|
|
fmt.Printf("You are now following the feed %q.\n", followRecord.FeedName)
|
|
fmt.Println("DEBUG:", followRecord)
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerFeeds(s *state, _ command) error {
|
|
feeds, err := s.db.GetAllFeeds(context.Background())
|
|
if err != nil {
|
|
return fmt.Errorf("unable to get the feeds from the database: %w", err)
|
|
}
|
|
|
|
fmt.Printf("Feeds:\n\n")
|
|
|
|
for _, feed := range feeds {
|
|
user, err := s.db.GetUserByID(context.Background(), feed.UserID)
|
|
if err != nil {
|
|
return fmt.Errorf(
|
|
"unable to get the creator of %s: %w",
|
|
feed.Name,
|
|
err,
|
|
)
|
|
}
|
|
|
|
fmt.Printf(
|
|
"- Name: %s\n URL: %s\n Created by: %s\n",
|
|
feed.Name,
|
|
feed.Url,
|
|
user.Name,
|
|
)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerFollow(s *state, cmd command, user database.User) error {
|
|
if len(cmd.args) != 1 {
|
|
return fmt.Errorf("unexpected number of arguments: want 2, got %d", len(cmd.args))
|
|
}
|
|
|
|
url := cmd.args[0]
|
|
|
|
feed, err := s.db.GetFeedByUrl(context.Background(), url)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to get the feed data from the database: %w", err)
|
|
}
|
|
|
|
timestamp := time.Now()
|
|
|
|
args := database.CreateFeedFollowParams{
|
|
ID: uuid.New(),
|
|
CreatedAt: timestamp,
|
|
UpdatedAt: timestamp,
|
|
UserID: user.ID,
|
|
FeedID: feed.ID,
|
|
}
|
|
|
|
followRecord, err := s.db.CreateFeedFollow(context.Background(), args)
|
|
if err != nil {
|
|
if uniqueViolation(err) {
|
|
return errors.New("you are already following this feed")
|
|
}
|
|
|
|
return fmt.Errorf("unable to create the feed follow record in the database: %w", err)
|
|
}
|
|
|
|
fmt.Printf("You are now following the feed %q.\n", followRecord.FeedName)
|
|
fmt.Println("DEBUG:", followRecord)
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerFollowing(s *state, _ command, user database.User) error {
|
|
following, err := s.db.GetFeedFollowsForUser(context.Background(), user.ID)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to get the list of feeds from the database: %w", err)
|
|
}
|
|
|
|
if len(following) == 0 {
|
|
fmt.Println("You are not following any feeds.")
|
|
|
|
return nil
|
|
}
|
|
|
|
fmt.Printf("\nYou are following:\n\n")
|
|
|
|
for _, feed := range following {
|
|
fmt.Printf("- %s\n", feed)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerUnfollow(s *state, cmd command, user database.User) error {
|
|
if len(cmd.args) != 1 {
|
|
return fmt.Errorf("unexpected number of arguments: want 2, got %d", len(cmd.args))
|
|
}
|
|
|
|
url := cmd.args[0]
|
|
|
|
feed, err := s.db.GetFeedByUrl(context.Background(), url)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to get the feed data from the database: %w", err)
|
|
}
|
|
|
|
args := database.DeleteFeedFollowParams{
|
|
UserID: user.ID,
|
|
FeedID: feed.ID,
|
|
}
|
|
|
|
if err := s.db.DeleteFeedFollow(context.Background(), args); err != nil {
|
|
return fmt.Errorf("unable to delete the feed follow record from the database: %w", err)
|
|
}
|
|
|
|
fmt.Printf("You have successfully unfollowed %q.\n", feed.Name)
|
|
|
|
return nil
|
|
}
|
|
|
|
func handlerBrowse(s *state, cmd command, user database.User) error {
|
|
if len(cmd.args) > 1 {
|
|
return fmt.Errorf("unexpected number of arguments: want 0 or 1, got %d", len(cmd.args))
|
|
}
|
|
|
|
var err error
|
|
|
|
limit := 2
|
|
|
|
if len(cmd.args) == 1 {
|
|
limit, err = strconv.Atoi(cmd.args[0])
|
|
if err != nil {
|
|
return fmt.Errorf("unable to convert %s to a number: %w", cmd.args[0], err)
|
|
}
|
|
}
|
|
|
|
args := database.GetPostsForUserParams{
|
|
UserID: user.ID,
|
|
Limit: int32(limit),
|
|
}
|
|
|
|
posts, err := s.db.GetPostsForUser(context.Background(), args)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to get the posts: %w", err)
|
|
}
|
|
|
|
fmt.Printf("\nPosts:\n\n")
|
|
|
|
for _, post := range posts {
|
|
fmt.Printf(
|
|
"- Title: %s\n URL: %s\n Published at: %s\n",
|
|
post.Title,
|
|
post.Url,
|
|
post.PublishedAt,
|
|
)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func scrapeFeeds(s *state) error {
|
|
feed, err := s.db.GetNextFeedToFetch(context.Background())
|
|
if err != nil {
|
|
return fmt.Errorf("unable to get the next feed from the database: %w", err)
|
|
}
|
|
|
|
fmt.Printf("\nFetching feed from %s\n", feed.Url)
|
|
|
|
feedDetails, err := rss.FetchFeed(context.Background(), feed.Url)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to fetch the feed: %w", err)
|
|
}
|
|
|
|
timestamp := time.Now()
|
|
|
|
lastFetched := sql.NullTime{
|
|
Time: timestamp,
|
|
Valid: true,
|
|
}
|
|
|
|
markFeedFetchedArgs := database.MarkFeedFetchedParams{
|
|
ID: feed.ID,
|
|
LastFetchedAt: lastFetched,
|
|
UpdatedAt: timestamp,
|
|
}
|
|
|
|
if err := s.db.MarkFeedFetched(context.Background(), markFeedFetchedArgs); err != nil {
|
|
return fmt.Errorf("unable to mark the feed as fetched in the database: %w", err)
|
|
}
|
|
|
|
timeParsingFormats := []string{
|
|
time.RFC1123Z,
|
|
time.RFC1123,
|
|
}
|
|
|
|
for _, item := range feedDetails.Channel.Items {
|
|
var (
|
|
pubDate time.Time
|
|
err error
|
|
)
|
|
|
|
pubDateFormatted := false
|
|
|
|
for _, format := range timeParsingFormats {
|
|
pubDate, err = time.Parse(format, item.PubDate)
|
|
if err == nil {
|
|
pubDateFormatted = true
|
|
|
|
break
|
|
}
|
|
}
|
|
|
|
if !pubDateFormatted {
|
|
fmt.Printf(
|
|
"Error: unable to format the publication date (%s) of %q.\n",
|
|
item.PubDate,
|
|
item.Title,
|
|
)
|
|
|
|
continue
|
|
}
|
|
|
|
timestamp := time.Now()
|
|
|
|
args := database.CreatePostParams{
|
|
ID: uuid.New(),
|
|
CreatedAt: timestamp,
|
|
UpdatedAt: timestamp,
|
|
Title: item.Title,
|
|
Url: item.Link,
|
|
Description: item.Description,
|
|
FeedID: feed.ID,
|
|
PublishedAt: pubDate,
|
|
}
|
|
|
|
_, err = s.db.CreatePost(context.Background(), args)
|
|
if err != nil && !uniqueViolation(err) {
|
|
fmt.Printf(
|
|
"Error: unable to add the post %q to the database: %v.\n",
|
|
item.Title,
|
|
err,
|
|
)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func uniqueViolation(err error) bool {
|
|
var pqError *pq.Error
|
|
|
|
if errors.As(err, &pqError) {
|
|
if pqError.Code.Name() == "unique_violation" {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|