Page MenuHomeMusing Studio
Files F10433557

posts.go
No OneTemporary
Actions

posts.go
View Options

package api
import (
"bufio"
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
"strings"
"time"
writeas "github.com/writeas/go-writeas/v2"
"github.com/writeas/writeas-cli/config"
"github.com/writeas/writeas-cli/fileutils"
"github.com/writeas/writeas-cli/log"
cli "gopkg.in/urfave/cli.v1"
)
const (
postsFile = "posts.psv"
separator = `|`
)
// Post holds the basic authentication information for a Write.as post.
type Post struct {
ID string
EditToken string
}
// RemotePost holds addition information about published
// posts
type RemotePost struct {
Post
Title,
Excerpt,
Slug,
Collection,
EditToken string
Synced bool
Updated time.Time
}
func AddPost(c *cli.Context, id, token string) error {
f, err := os.OpenFile(filepath.Join(config.UserDataDir(c.App.ExtraInfo()["configDir"]), postsFile), os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0600)
if err != nil {
return fmt.Errorf("Error creating local posts list: %s", err)
}
defer f.Close()
l := fmt.Sprintf("%s%s%s\n", id, separator, token)
if _, err = f.WriteString(l); err != nil {
return fmt.Errorf("Error writing to local posts list: %s", err)
}
return nil
}
// ClaimPost adds a local post to the authenticated user's account and deletes
// the local reference
func ClaimPosts(c *cli.Context, localPosts *[]Post) (*[]writeas.ClaimPostResult, error) {
cl, err := newClient(c, true)
if err != nil {
return nil, err
}
postsToClaim := make([]writeas.OwnedPostParams, len(*localPosts))
for i, post := range *localPosts {
postsToClaim[i] = writeas.OwnedPostParams{
ID: post.ID,
Token: post.EditToken,
}
}
return cl.ClaimPosts(&postsToClaim)
}
func TokenFromID(c *cli.Context, id string) string {
post := fileutils.FindLine(filepath.Join(config.UserDataDir(c.App.ExtraInfo()["configDir"]), postsFile), id)
if post == "" {
return ""
}
parts := strings.Split(post, separator)
if len(parts) < 2 {
return ""
}
return parts[1]
}
func RemovePost(path, id string) {
fileutils.RemoveLine(filepath.Join(config.UserDataDir(path), postsFile), id)
}
func GetPosts(c *cli.Context) *[]Post {
lines := fileutils.ReadData(filepath.Join(config.UserDataDir(c.App.ExtraInfo()["configDir"]), postsFile))
posts := []Post{}
if lines != nil && len(*lines) > 0 {
parts := make([]string, 2)
for _, l := range *lines {
parts = strings.Split(l, separator)
if len(parts) < 2 {
continue
}
posts = append(posts, Post{ID: parts[0], EditToken: parts[1]})
}
}
return &posts
}
func GetUserPosts(c *cli.Context) ([]RemotePost, error) {
waposts, err := DoFetchPosts(c)
if err != nil {
return nil, err
}
if len(waposts) == 0 {
return nil, nil
}
posts := []RemotePost{}
for _, p := range waposts {
post := RemotePost{
Post: Post{
ID: p.ID,
EditToken: p.Token,
},
Title: p.Title,
Excerpt: getExcerpt(p.Content),
Slug: p.Slug,
Synced: p.Slug != "",
Updated: p.Updated,
}
if p.Collection != nil {
post.Collection = p.Collection.Alias
}
posts = append(posts, post)
}
return posts, nil
}
// getExcerpt takes in a content string and returns
// a concatenated version. limited to no more than
// two lines of 80 chars each. delimited by '...'
func getExcerpt(input string) string {
length := len(input)
if length <= 80 {
return input
} else if length < 160 {
ln1, idx := trimToLength(input, 80)
if idx == -1 {
idx = 80
}
ln2, _ := trimToLength(input[idx:], 80)
return ln1 + "\n" + ln2
} else {
excerpt := input[:158]
ln1, idx := trimToLength(excerpt, 80)
if idx == -1 {
idx = 80
}
ln2, _ := trimToLength(excerpt[idx:], 80)
return ln1 + "\n" + ln2 + "..."
}
}
func trimToLength(in string, l int) (string, int) {
c := []rune(in)
spaceIdx := -1
length := len(c)
if length <= l {
return in, spaceIdx
}
for i := l; i > 0; i-- {
if c[i] == ' ' {
spaceIdx = i
break
}
}
if spaceIdx > -1 {
c = c[:spaceIdx]
}
return string(c), spaceIdx
}
func ComposeNewPost() (string, *[]byte) {
f, err := fileutils.TempFile(os.TempDir(), "WApost", "txt")
if err != nil {
if config.Debug() {
panic(err)
} else {
log.Errorln("Error creating temp file: %s", err)
return "", nil
}
}
f.Close()
cmd := config.EditPostCmd(f.Name())
if cmd == nil {
os.Remove(f.Name())
fmt.Println(config.NoEditorErr)
return "", nil
}
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
if err := cmd.Start(); err != nil {
os.Remove(f.Name())
if config.Debug() {
panic(err)
} else {
log.Errorln("Error starting editor: %s", err)
return "", nil
}
}
// If something fails past this point, the temporary post file won't be
// removed automatically. Calling function should handle this.
if err := cmd.Wait(); err != nil {
if config.Debug() {
panic(err)
} else {
log.Errorln("Editor finished with error: %s", err)
return "", nil
}
}
post, err := ioutil.ReadFile(f.Name())
if err != nil {
if config.Debug() {
panic(err)
} else {
log.Errorln("Error reading post: %s", err)
return "", nil
}
}
return f.Name(), &post
}
func WritePost(postsDir string, p *writeas.Post) error {
postFilename := p.ID
collDir := ""
if p.Collection != nil {
postFilename = p.Slug
collDir = p.Collection.Alias
}
postFilename += PostFileExt
txtFile := p.Content
if p.Title != "" {
txtFile = "# " + p.Title + "\n\n" + txtFile
}
return ioutil.WriteFile(filepath.Join(postsDir, collDir, postFilename), []byte(txtFile), 0644)
}
func ReadStdIn() []byte {
numBytes, numChunks := int64(0), int64(0)
r := bufio.NewReader(os.Stdin)
fullPost := []byte{}
buf := make([]byte, 0, 1024)
for {
n, err := r.Read(buf[:cap(buf)])
buf = buf[:n]
if n == 0 {
if err == nil {
continue
}
if err == io.EOF {
break
}
log.ErrorlnQuit("Error reading from stdin: %v", err)
}
numChunks++
numBytes += int64(len(buf))
fullPost = append(fullPost, buf...)
if err != nil && err != io.EOF {
log.ErrorlnQuit("Error appending to end of post: %v", err)
}
}
return fullPost
}

File Metadata

Mime Type
text/x-pascal
Expires
Mon, Jan 20, 4:54 AM (1 d, 20 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3136461

Event Timeline

musing studio · developers