Jonathan Bernard
a28f1540c4
This is a normal case when you go a really long time without syncing and the issues fall off of the pit time horizon. Also, bump versions to support Nim 2.x
263 lines
8.3 KiB
Nim
263 lines
8.3 KiB
Nim
## Sync Personal Issue Tracker to Trello
|
|
|
|
import std/[algorithm, json, jsonutils, logging, options, sets, times, tables]
|
|
import cliutils, docopt, pit, uuids, zero_functional
|
|
|
|
import pit2trellopkg/[api, cliconstants]
|
|
|
|
from sequtils import toSeq
|
|
|
|
type
|
|
CliConfig = ref object
|
|
pit*: PitConfig
|
|
apiBaseUrl*: string
|
|
apiKey*: TrelloApiCredentials
|
|
contexts*: seq[TrelloContext]
|
|
|
|
TrelloContext = object
|
|
context*: string
|
|
boardId*: string
|
|
|
|
SyncState = ref object
|
|
pit*: PitConfig
|
|
boards*: TableRef[string, TrelloBoard]
|
|
contexts*: seq[TrelloContext]
|
|
issues*: TableRef[IssueState, seq[Issue]]
|
|
|
|
func distribute[K, V](a: K, s: seq[V]): seq[(K, V)] =
|
|
s --> map((a, it))
|
|
|
|
proc loadBoards(
|
|
self: TrelloApiClient,
|
|
contexts: seq[TrelloContext]
|
|
): TableRef[string, TrelloBoard] =
|
|
|
|
let boards: seq[tuple[id: string, board: TrelloBoard]] = contexts -->
|
|
map((it.boardId, self.loadBoard(it.boardId)))
|
|
return newTable[string, TrelloBoard](boards)
|
|
|
|
proc loadCliConfig(args: Table[string, Value]): CliConfig =
|
|
let pitCfg = loadConfig(args)
|
|
|
|
let trelloJson = pitCfg.cfg.getJson("trello")
|
|
let trelloCfg = CombinedConfig(docopt: args, json: trelloJson)
|
|
|
|
result = CliConfig(
|
|
apiBaseUrl: trelloCfg.getVal("api-base-url", "https://api.trello.com"),
|
|
pit: pitCfg
|
|
)
|
|
|
|
fromJson(result.apiKey, trelloCfg.getJson("apiKey"))
|
|
fromJson(result.contexts, trelloCfg.getJson("contexts"))
|
|
|
|
proc loadIssuesAndBoards(cfg: CliConfig, trello: TrelloApiClient): SyncState =
|
|
SyncState(
|
|
pit: cfg.pit,
|
|
boards: trello.loadBoards(cfg.contexts),
|
|
contexts: cfg.contexts,
|
|
issues: cfg.pit.tasksDir.loadAllIssues)
|
|
|
|
proc listCategoryForIssueState(issState: IssueState): TrelloListCategory =
|
|
return
|
|
case issState:
|
|
of Current, TodoToday, Pending: tlcInProgress
|
|
of Dormant, Todo: tlcTodo
|
|
of Done: tlcDone
|
|
|
|
proc issueStateForListCategory(listCategory: TrelloListCategory): IssueState =
|
|
return
|
|
case listCategory:
|
|
of tlcTodo: Todo
|
|
of tlcInProgress: TodoToday
|
|
of tlcDone, tlcUnknown: Done
|
|
|
|
proc tagToTrelloLabel(trello: TrelloApiClient, board: TrelloBoard, tag: string): TrelloLabel =
|
|
let foundLabel = board.labels --> find(it.name == tag)
|
|
if foundLabel.isSome: return foundLabel.get
|
|
else: return trello.createLabel(board, tag)
|
|
|
|
proc trelloLabelIdToTag(board: TrelloBoard, labelId: string): Option[string] =
|
|
let foundLabel = board.labels --> find(it.id == labelId)
|
|
if foundLabel.isSome: return some(foundLabel.get.name)
|
|
else: return none[string]()
|
|
|
|
proc equiv(board: TrelloBoard, tc: TrelloCard, iss: Issue): bool =
|
|
return
|
|
tc.name == iss.summary and
|
|
tc.desc == iss.details and
|
|
sorted(iss.tags) == sorted(tc.labelIds -->
|
|
map(board.trelloLabelIdToTag(it)).
|
|
filter(it.isSome).
|
|
map(it.get))
|
|
|
|
type TrelloListSummary = tuple[category: TrelloListCategory, id: string]
|
|
|
|
proc syncContext(
|
|
trello: TrelloApiClient,
|
|
s: SyncState,
|
|
ctx: TrelloContext,
|
|
dryRun = true) =
|
|
if not s.boards.contains(ctx.boardId):
|
|
raise newException(ValueError, "board not loaded for context\t" & $ctx)
|
|
|
|
let board = s.boards[ctx.boardId]
|
|
|
|
let issues = s.issues.find(
|
|
propsFilter(newTable([("context", ctx.context)])))
|
|
|
|
let cards: seq[tuple[list: TrelloListSummary, card: TrelloCard]] =
|
|
board.lists.pairs.toSeq -->
|
|
map(distribute(it[0], it[1])).flatten().
|
|
map(distribute((category: it[0], id: it[1].id), it[1].cards)).flatten()
|
|
|
|
## We're going to do a bi-direction sync. First we will iterate through the
|
|
## issues and cards identifying matches.
|
|
var unmatchedCardIds = toHashSet(cards --> map(it[1].id))
|
|
var unmatchedIssueIds = toHashSet(issues --> map($it.id))
|
|
var matched = newSeq[tuple[
|
|
issue: Issue,
|
|
card: TrelloCard,
|
|
list: TrelloListSummary]]()
|
|
|
|
## 1. Look for issues that already have a `trello-card-id` property.
|
|
for i in issues:
|
|
if i.hasProp("trello-card-id"):
|
|
let cardId = i["trello-card-id"]
|
|
let foundCard = cards --> find(it.card.id == cardId)
|
|
|
|
if foundCard.isNone:
|
|
## Ignore issues that are completed (may be archived in Trello)
|
|
if i.state == Done: unmatchedIssueIds.excl($i.id)
|
|
else:
|
|
raise newException(Exception,
|
|
"pit issue " & ($i.id)[0..6] & " references a Trello card with id " &
|
|
cardId & " but that card is not any of the lists of the " &
|
|
board.name & " board.")
|
|
|
|
else:
|
|
let c = foundCard.get
|
|
matched.add((issue: i, card: c.card, list: c.list))
|
|
unmatchedCardIds.excl(c.card.id)
|
|
unmatchedIssueIds.excl($i.id)
|
|
|
|
## 2. Process updates to the matched cards
|
|
for (lentIssue, lentCard, lentList) in matched:
|
|
let (issue, card, list) = (lentIssue, lentCard, lentList)
|
|
let pitListCategory = listCategoryForIssueState(issue.state)
|
|
|
|
## 2.a Ignore cards that have no differences (have the same contents and
|
|
## are in the same list category)
|
|
if board.equiv(card, issue) and pitListCategory == list.category: continue
|
|
|
|
if issue.hasProp("last-updated") and
|
|
issue.getDateTime("last-updated") > card.lastUpdatedAt:
|
|
|
|
# The PIT issue is newer
|
|
let newCard = TrelloCard(
|
|
id: card.id,
|
|
desc: issue.details,
|
|
name: issue.summary,
|
|
labelIds: issue.tags --> map(trello.tagToTrelloLabel(board, it).id))
|
|
|
|
if not dryRun:
|
|
var targetListId: string
|
|
if pitListCategory != list.category:
|
|
targetListId =
|
|
board.lists[listCategoryForIssueState(issue.state)][0].id
|
|
else: targetListId = list.id
|
|
trello.updateCard(newCard, targetListId)
|
|
|
|
info "Trello updated: " & formatSectionIssue(issue, width = 64) &
|
|
" " & $list.category & " --> " & $pitListCategory
|
|
|
|
else:
|
|
# The Trello issue is newer
|
|
issue.summary = card.name
|
|
issue.details = card.desc
|
|
issue.tags = card.labelIds -->
|
|
map(board.trelloLabelIdToTag(it)).
|
|
filter(it.isSome).
|
|
map(it.get)
|
|
|
|
if not dryRun:
|
|
if pitListCategory != list.category:
|
|
issue.changeState(s.pit.tasksDir, issueStateForListCategory(list.category))
|
|
else: issue.store
|
|
|
|
info "pit updated: " & formatSectionIssue(issue, width = 64) &
|
|
" " & $pitListCategory & " --> " & $list.category
|
|
|
|
let unmatchedCards = cards --> filter(unmatchedCardIds.contains(it.card.id))
|
|
let unmatchedIssues = issues --> filter(unmatchedIssueIds.contains($it.id))
|
|
|
|
for (list, lentCard) in unmatchedCards:
|
|
let (list, card) = (list, lentCard)
|
|
let issueState = issueStateForListCategory(list.category)
|
|
|
|
# Don't worry about creating new issues for cards that are done.
|
|
if issueState == Done: continue
|
|
|
|
let issue = Issue(
|
|
id: genUUID(),
|
|
summary: card.name,
|
|
details: card.desc,
|
|
properties: newTable({
|
|
"context": ctx.context,
|
|
"trello-card-id": card.id
|
|
}),
|
|
tags: card.labelIds -->
|
|
map(board.trelloLabelIdToTag(it)).
|
|
filter(it.isSome).
|
|
map(it.get))
|
|
|
|
if not dryRun: s.pit.tasksDir.store(issue, issueState)
|
|
info "pit created: " & formatSectionIssue(issue, width = 64) & " " &
|
|
$issueState
|
|
|
|
for lentIssue in unmatchedIssues:
|
|
let issue = lentIssue
|
|
|
|
# Don't worry about creating new cards for issues that are done.
|
|
if issue.state == Done: continue
|
|
|
|
let list = board.lists[listCategoryForIssueState(issue.state)][0]
|
|
let newCard = TrelloCard(
|
|
name: issue.summary,
|
|
desc: issue.details,
|
|
labelIds: issue.tags --> map(trello.tagToTrelloLabel(board, it).id))
|
|
|
|
if not dryRun:
|
|
let createdCard = trello.createCard(newCard, list)
|
|
issue["trello-card-id"] = createdCard.id
|
|
issue.store
|
|
|
|
info "Trello created: " & formatSectionIssue(issue, width = 64) & " " &
|
|
list.name
|
|
|
|
when isMainModule:
|
|
try:
|
|
|
|
let consoleLogger = newConsoleLogger(
|
|
levelThreshold = lvlInfo,
|
|
fmtStr = "pit2trello - $levelname: ")
|
|
logging.addHandler(consoleLogger)
|
|
|
|
let args = docopt(USAGE, version = PIT2TRELLO_VERSION)
|
|
|
|
if args["--debug"]:
|
|
consoleLogger.levelThreshold = lvlDebug
|
|
|
|
var cfg = loadCliConfig(args)
|
|
|
|
if args["sync"]:
|
|
let trello = initTrelloApiClient(cfg.apiKey, cfg.apiBaseUrl)
|
|
let state = loadIssuesAndBoards(cfg, trello)
|
|
|
|
for ctx in cfg.contexts: trello.syncContext(state, ctx, args["--dry-run"])
|
|
|
|
except CatchableError:
|
|
let ex = getCurrentException()
|
|
fatal ex.msg
|
|
debug ex.getStackTrace
|
|
quit(QuitFailure)
|