intake/cmd/actionExecute.go

package cmd

import (
	"encoding/json"
	"fmt"
	"log"
	"time"

	"github.com/Jaculabilis/intake/core"
	"github.com/spf13/cobra"
)

var actionExecuteCmd = &cobra.Command{
	Use:     "execute",
	Aliases: []string{"exec"},
	Short:   "Run a source action for an item",
	Long: fmt.Sprintf(`Execute a source action for an item.

The item must declare support for the action by having the action's name
in its "action" field. Use --force to execute the action anyway.

The "fetch" action is special and does not execute for any specific item.
Use "intake source fetch" to run the fetch action.

In a dry run, the item will be printed in the chosen format and not updated.

%s`, makeFormatHelpText()),
	Run: func(cmd *cobra.Command, args []string) {
		actionExecute()
	},
}

var actionExecuteSource string
var actionExecuteAction string
var actionExecuteItem string
var actionExecuteFormat string
var actionExecuteDryRun bool
var actionExecuteDiff bool
var actionExecuteForce bool

func init() {
	actionCmd.AddCommand(actionExecuteCmd)

	actionExecuteCmd.PersistentFlags().StringVarP(&actionExecuteSource, "source", "s", "", "Source of the item")
	actionExecuteCmd.MarkFlagRequired("source")

	actionExecuteCmd.PersistentFlags().StringVarP(&actionExecuteItem, "item", "i", "", "Item to run action on")
	actionExecuteCmd.MarkFlagRequired("item")

	actionExecuteCmd.PersistentFlags().StringVarP(&actionExecuteAction, "action", "a", "", "Action to run")
	actionExecuteCmd.MarkFlagRequired("action")

	actionExecuteCmd.Flags().StringVarP(&actionExecuteFormat, "format", "f", "headlines", "Feed format for returned items")
	actionExecuteCmd.Flags().BoolVar(&actionExecuteDryRun, "dry-run", false, "Instead of updating the item, print it")

	actionExecuteCmd.Flags().BoolVar(&actionExecuteDiff, "diff", false, "Show which fields of the item changed")

	actionExecuteCmd.Flags().BoolVar(&actionExecuteForce, "force", false, "Execute the action even if the item does not support it")
}

func actionExecute() {
	formatter := formatAs(actionExecuteFormat)

	if actionExecuteSource == "" {
		log.Fatal("error: --source is empty")
	}
	if actionExecuteAction == "" {
		log.Fatal("error: --action is empty")
	}
	if actionExecuteItem == "" {
		log.Fatal("error: --item is empty")
	}

	db := openAndMigrateDb()

	item, err := core.GetItem(db, actionExecuteSource, actionExecuteItem)
	if err != nil {
		log.Fatalf("error: failed to get item: %v", err)
	}

	if item.Action[actionExecuteAction] == nil {
		if actionExecuteForce {
			log.Printf("warning: force-executing %s on %s/%s", actionExecuteAction, actionExecuteSource, actionExecuteItem)
		} else {
			log.Fatalf("error: %s/%s does not support %s", actionExecuteSource, actionExecuteItem, actionExecuteAction)
		}
	}

	argv, err := core.GetArgvForAction(db, actionExecuteSource, actionExecuteAction)
	if err != nil {
		log.Fatalf("error: failed to get action: %v", err)
	}

	itemJson, err := json.Marshal(item)
	if err != nil {
		log.Fatalf("error: failed to serialize item: %v", err)
	}

	res, err := core.Execute(actionExecuteSource, argv, nil, string(itemJson), time.Minute)
	if err != nil {
		log.Fatalf("error: failed to execute action: %v", err)
	}
	if len(res) != 1 {
		log.Fatalf("error: expected action to produce exactly one item, got %d", len(res))
	}
	newItem := res[0]
	core.BackfillItem(&newItem, &item)

	if actionExecuteDiff {
		if item.Title != newItem.Title {
			log.Printf("title: %s => %s", item.Title, newItem.Title)
		}
		if item.Author != newItem.Author {
			log.Printf("author: %s => %s", item.Author, newItem.Author)
		}
		if item.Body != newItem.Body {
			log.Printf("body: %s => %s", item.Body, newItem.Body)
		}
		if item.Link != newItem.Link {
			log.Printf("link: %s => %s", item.Link, newItem.Link)
		}
		if item.Time != newItem.Time {
			log.Printf("time: %d => %d", item.Time, newItem.Time)
		}
		if core.ItemsAreEqual(item, newItem) {
			log.Printf("no changes\n")
		}
	}

	if actionExecuteDryRun {
		fmt.Println(formatter(res[0]))
		return
	}

	if err = core.UpdateItems(db, []core.Item{newItem}); err != nil {
		log.Fatalf("error: failed to update item: %v", err)
	}
}