miniflux-archiver/internal/service/linkding.go

package service

import (
	"encoding/json"
	"fmt"
	"net/http"

	ldApi "github.com/piero-vic/go-linkding"
)

type Linkding struct {
	ServiceConfig
	client *ldApi.Client
}

func (ld *Linkding) CheckBookmark(url string) (*ldApi.Bookmark, error) {
	bookmark := &ldApi.Bookmark{}

	req, err := http.NewRequest(
		http.MethodGet,
		fmt.Sprintf("%v/api/bookmarks/check/?url=%d", ld.Host, url),
		nil,
	)
	if err != nil {
		return bookmark, err
	}

	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Accept", "application/json")
	req.Header.Add("Authorization", fmt.Sprintf("Token %s", ld.Token))

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return bookmark, err
	}

	defer res.Body.Close()

	if err := json.NewDecoder(res.Body).Decode(bookmark); err != nil {
		return bookmark, err
	}

	return bookmark, nil
}

func (ld *Linkding) Archive(url string) error {
	bookmark, err := ld.CheckBookmark(url)

	payload := ldApi.CreateBookmarkRequest{
		URL:      url,
		Unread:   false,
		TagNames: bookmark.TagNames,
	}

	switch ld.ServiceConfig.Method {
	case ServiceArchiveMethodArchive:
		payload.IsArchived = true
	case ServiceArchiveMethodSeen:
		payload.Unread = false
	case ServiceArchiveMethodBoth:
		payload.Unread = false
		payload.IsArchived = true
	default:
		return fmt.Errorf("Archive method is invalid")
	}

	if payload.TagNames == nil {
		payload.TagNames = []string{}
	}

	if err != nil {
		_, err = ld.client.UpdateBookmark(bookmark.ID, payload)
	} else {
		_, err = ld.client.CreateBookmark(payload)
	}

	return err
}

func (ld *Linkding) IsAvailable() (bool, error) {
	_, err := ld.client.ListTags(ldApi.ListTagsParams{})

	return err == nil, err
}

func NewLinkding(config ServiceConfig) (*Linkding, error) {
	mf := &Linkding{
		ServiceConfig: config,
		client:        ldApi.NewClient(config.Host, config.Token),
	}

	return mf, nil
}