checkpoint: add default user posting preferences for consideration

internal/client/statuses.go

@@ -1,6 +1,8 @@
 package client
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"net/http"
 
@@ -22,3 +24,59 @@ func (g *Client) GetStatus(statusID string) (model.Status, error) {
 
 	return status, nil
 }
+
+func (g *Client) CreateStatus(
+	content,
+	contentType,
+	language,
+	spoilerText string,
+	boostable,
+	federated,
+	likeable,
+	replyable,
+	sensitive bool,
+	visibility model.StatusVisibility,
+) (model.Status, error) {
+	form := struct {
+		ContentType string                 `json:"content_type"`
+		Language    string                 `json:"language"`
+		SpoilerText string                 `json:"spoiler_text"`
+		Status      string                 `json:"status"`
+		Boostable   bool                   `json:"boostable"`
+		Federated   bool                   `json:"federated"`
+		Likeable    bool                   `json:"likeable"`
+		Replyable   bool                   `json:"replyable"`
+		Sensitive   bool                   `json:"sensitive"`
+		Visibility  model.StatusVisibility `json:"visibility"`
+	}{
+		ContentType: contentType,
+		Language:    language,
+		SpoilerText: spoilerText,
+		Status:      content,
+		Boostable:   boostable,
+		Federated:   federated,
+		Likeable:    likeable,
+		Sensitive:   sensitive,
+		Replyable:   replyable,
+		Visibility:  visibility,
+	}
+
+	data, err := json.Marshal(form)
+	if err != nil {
+		return model.Status{}, fmt.Errorf("unable to create the JSON form; %w", err)
+	}
+
+	requestBody := bytes.NewBuffer(data)
+	url := g.Authentication.Instance + "/api/v1/statuses"
+
+	var status model.Status
+
+	if err := g.sendRequest(http.MethodPost, url, requestBody, &status); err != nil {
+		return model.Status{}, fmt.Errorf(
+			"received an error after sending the request to create the status; %w",
+			err,
+		)
+	}
+
+	return status, nil
+}

internal/executor/const.go

@@ -2,24 +2,33 @@ package executor
 
 const (
 	flagAccountName       = "account-name"
+	flagBoostable         = "boostable"
 	flagBrowser           = "browser"
+	flagContentType       = "content-type"
 	flagContent           = "content"
+	flagFederated         = "federated"
+	flagFrom              = "from"
 	flagInstance          = "instance"
+	flagLanguage          = "language"
+	flagLikeable          = "likeable"
 	flagLimit             = "limit"
 	flagListID            = "list-id"
 	flagListTitle         = "list-title"
 	flagListRepliesPolicy = "list-replies-policy"
 	flagMyAccount         = "my-account"
 	flagNotify            = "notify"
-	flagFrom              = "from"
-	flagType              = "type"
+	flagReplyable         = "replyable"
+	flagSensitive         = "sensitive"
 	flagSkipRelationship  = "skip-relationship"
 	flagShowPreferences   = "show-preferences"
 	flagShowReposts       = "show-reposts"
+	flagSpoilerText       = "spoiler-text"
 	flagStatusID          = "status-id"
 	flagTag               = "tag"
 	flagTimelineCategory  = "timeline-category"
 	flagTo                = "to"
+	flagType              = "type"
+	flagVisibility        = "visibility"
 
 	resourceAccount   = "account"
 	resourceBlocked   = "blocked"

internal/executor/create.go

@@ -12,9 +12,19 @@ type CreateExecutor struct {
 	*flag.FlagSet
 
 	topLevelFlags     TopLevelFlags
+	boostable         bool
+	federated         bool
+	likeable          bool
+	replyable         bool
+	sensitive         bool
+	content           string
+	contentType       string
+	language          string
+	spoilerText       string
 	resourceType      string
 	listTitle         string
 	listRepliesPolicy string
+	visibility        string
 }
 
 func NewCreateExecutor(tlf TopLevelFlags, name, summary string) *CreateExecutor {
@@ -24,6 +34,16 @@ func NewCreateExecutor(tlf TopLevelFlags, name, summary string) *CreateExecutor
 		topLevelFlags: tlf,
 	}
 
+	createExe.BoolVar(&createExe.boostable, flagBoostable, true, "specify if the status can be reposted/boosted by others")
+	createExe.BoolVar(&createExe.federated, flagFederated, true, "specify if the status can be federated beyond the local timelines")
+	createExe.BoolVar(&createExe.likeable, flagLikeable, true, "specify if the status can be liked/favourited")
+	createExe.BoolVar(&createExe.replyable, flagReplyable, true, "specify if the status can be replied to")
+	createExe.BoolVar(&createExe.sensitive, flagSensitive, false, "specify if the status should be marked as sensitive")
+	createExe.StringVar(&createExe.content, flagContent, "", "the content of the status to create")
+	createExe.StringVar(&createExe.contentType, flagContentType, "text/plain", "the type that the contents should be parsed from (valid values are plain and markdown)")
+	createExe.StringVar(&createExe.language, flagLanguage, "", "the ISO 639 language code for this status")
+	createExe.StringVar(&createExe.spoilerText, flagSpoilerText, "", "the text to display as the status' warning or subject")
+	createExe.StringVar(&createExe.visibility, flagVisibility, "", "the visibility of the posted status")
 	createExe.StringVar(&createExe.resourceType, flagType, "", "specify the type of resource to create")
 	createExe.StringVar(&createExe.listTitle, flagListTitle, "", "specify the title of the list")
 	createExe.StringVar(&createExe.listRepliesPolicy, flagListRepliesPolicy, "list", "specify the policy of the replies for this list (valid values are followed, list and none)")
@@ -44,7 +64,8 @@ func (c *CreateExecutor) Execute() error {
 	}
 
 	funcMap := map[string]func(*client.Client) error{
-		resourceList: c.createList,
+		resourceList:   c.createList,
+		resourceStatus: c.createStatus,
 	}
 
 	doFunc, ok := funcMap[c.resourceType]
@@ -75,3 +96,57 @@ func (c *CreateExecutor) createList(gtsClient *client.Client) error {
 
 	return nil
 }
+
+func (c *CreateExecutor) createStatus(gtsClient *client.Client) error {
+	if c.content == "" {
+		return FlagNotSetError{flagText: flagContent}
+	}
+
+	var (
+		language   string
+		visibility string
+	)
+
+	preferences, err := gtsClient.GetUserPreferences()
+	if err != nil {
+		fmt.Println("WARNING: Unable to get your posting preferences; %w", err)
+	}
+
+	if c.language != "" {
+		language = c.language
+	} else {
+		language = preferences.PostingDefaultLanguage
+	}
+
+	if c.visibility != "" {
+		visibility = c.visibility
+	} else {
+		visibility = preferences.PostingDefaultVisibility
+	}
+
+	parsedVisibility := model.ParseStatusVisibility(visibility)
+	if parsedVisibility == model.StatusVisibilityUnknown {
+		return fmt.Errorf("invalid status visibility %q", visibility)
+	}
+
+	status, err := gtsClient.CreateStatus(
+		c.content,
+		c.contentType,
+		language,
+		c.spoilerText,
+		c.boostable,
+		c.federated,
+		c.likeable,
+		c.replyable,
+		c.sensitive,
+		parsedVisibility,
+	)
+	if err != nil {
+		return fmt.Errorf("unable to create the status; %w", err)
+	}
+
+	fmt.Println("Successfully created the following status:")
+	fmt.Println(status)
+
+	return nil
+}

internal/model/list.go

@@ -26,7 +26,7 @@ func ParseListRepliesPolicy(policy string) (ListRepliesPolicy, error) {
 		return ListRepliesPolicyNone, nil
 	}
 
-	return ListRepliesPolicy(-1), errors.New("invalid list replies policy")
+	return ListRepliesPolicy(-1), fmt.Errorf("%q is not a valid list replies policy", policy)
 }
 
 func (l ListRepliesPolicy) String() string {
@@ -43,12 +43,12 @@ func (l ListRepliesPolicy) String() string {
 }
 
 func (l ListRepliesPolicy) MarshalJSON() ([]byte, error) {
-	str := l.String()
-	if str == "" {
+	value := l.String()
+	if value == "" {
 		return nil, errors.New("invalid list replies policy")
 	}
 
-	return json.Marshal(str)
+	return json.Marshal(value)
 }
 
 func (l *ListRepliesPolicy) UnmarshalJSON(data []byte) error {

internal/model/status.go

@@ -1,6 +1,7 @@
 package model
 
 import (
+	"encoding/json"
 	"fmt"
 	"time"
 
@@ -36,7 +37,7 @@ type Status struct {
 	Text               string           `json:"text"`
 	URI                string           `json:"uri"`
 	URL                string           `json:"url"`
-	Visibility         string           `json:"visibility"`
+	Visibility         StatusVisibility `json:"visibility"`
 }
 
 type Card struct {
@@ -82,34 +83,34 @@ type PollOption struct {
 }
 
 type StatusReblogged struct {
-	Account            Account      `json:"account"`
-	Application        Application  `json:"application"`
-	Bookmarked         bool         `json:"bookmarked"`
-	Card               Card         `json:"card"`
-	Content            string       `json:"content"`
-	CreatedAt          time.Time    `json:"created_at"`
-	Emojis             []Emoji      `json:"emojis"`
-	Favourited         bool         `json:"favourited"`
-	FavouritesCount    int          `json:"favourites_count"`
-	ID                 string       `json:"id"`
-	InReplyToAccountID string       `json:"in_reply_to_account_id"`
-	InReplyToID        string       `json:"in_reply_to_id"`
-	Language           string       `json:"language"`
-	MediaAttachments   []Attachment `json:"media_attachments"`
-	Mentions           []Mention    `json:"mentions"`
-	Muted              bool         `json:"muted"`
-	Pinned             bool         `json:"pinned"`
-	Poll               Poll         `json:"poll"`
-	Reblogged          bool         `json:"reblogged"`
-	RebloggsCount      int          `json:"reblogs_count"`
-	RepliesCount       int          `json:"replies_count"`
-	Sensitive          bool         `json:"sensitive"`
-	SpolierText        string       `json:"spoiler_text"`
-	Tags               []Tag        `json:"tags"`
-	Text               string       `json:"text"`
-	URI                string       `json:"uri"`
-	URL                string       `json:"url"`
-	Visibility         string       `json:"visibility"`
+	Account            Account          `json:"account"`
+	Application        Application      `json:"application"`
+	Bookmarked         bool             `json:"bookmarked"`
+	Card               Card             `json:"card"`
+	Content            string           `json:"content"`
+	CreatedAt          time.Time        `json:"created_at"`
+	Emojis             []Emoji          `json:"emojis"`
+	Favourited         bool             `json:"favourited"`
+	FavouritesCount    int              `json:"favourites_count"`
+	ID                 string           `json:"id"`
+	InReplyToAccountID string           `json:"in_reply_to_account_id"`
+	InReplyToID        string           `json:"in_reply_to_id"`
+	Language           string           `json:"language"`
+	MediaAttachments   []Attachment     `json:"media_attachments"`
+	Mentions           []Mention        `json:"mentions"`
+	Muted              bool             `json:"muted"`
+	Pinned             bool             `json:"pinned"`
+	Poll               Poll             `json:"poll"`
+	Reblogged          bool             `json:"reblogged"`
+	RebloggsCount      int              `json:"reblogs_count"`
+	RepliesCount       int              `json:"replies_count"`
+	Sensitive          bool             `json:"sensitive"`
+	SpolierText        string           `json:"spoiler_text"`
+	Tags               []Tag            `json:"tags"`
+	Text               string           `json:"text"`
+	URI                string           `json:"uri"`
+	URL                string           `json:"url"`
+	Visibility         StatusVisibility `json:"visibility"`
 }
 
 type Tag struct {
@@ -195,3 +196,72 @@ func (s Status) String() string {
 		s.URL,
 	)
 }
+
+type StatusVisibility int
+
+const (
+	StatusVisibilityPublic StatusVisibility = iota
+	StatusVisibilityPrivate
+	StatusVisibilityUnlisted
+	StatusVisibilityMutualsOnly
+	StatusVisibilityDirect
+	StatusVisibilityUnknown
+)
+
+func (s StatusVisibility) String() string {
+	switch s {
+	case StatusVisibilityPublic:
+		return "public"
+	case StatusVisibilityPrivate:
+		return "private"
+	case StatusVisibilityUnlisted:
+		return "unlisted"
+	case StatusVisibilityMutualsOnly:
+		return "mutuals_only"
+	case StatusVisibilityDirect:
+		return "direct"
+	}
+
+	return "unknown"
+}
+
+func ParseStatusVisibility(visibility string) StatusVisibility {
+	switch visibility {
+	case "public":
+		return StatusVisibilityPublic
+	case "private":
+		return StatusVisibilityPrivate
+	case "unlisted":
+		return StatusVisibilityUnlisted
+	case "mutuals_only":
+		return StatusVisibilityMutualsOnly
+	case "direct":
+		return StatusVisibilityDirect
+	}
+
+	return StatusVisibilityUnknown
+}
+
+func (s StatusVisibility) MarshalJSON() ([]byte, error) {
+	value := s.String()
+	if value == "unknown" {
+		return nil, fmt.Errorf("%q is not a valid status visibility", value)
+	}
+
+	return json.Marshal(value)
+}
+
+func (s *StatusVisibility) UnmarshalJSON(data []byte) error {
+	var (
+		value string
+		err   error
+	)
+
+	if err = json.Unmarshal(data, &value); err != nil {
+		return fmt.Errorf("unable to unmarshal the data; %w", err)
+	}
+
+	*s = ParseStatusVisibility(value)
+
+	return nil
+}