Merge lp:~canonical-hwe-team/lp2kanban/hwe into lp:~launchpad/lp2kanban/trunk

[Chris Van Hoof]

[ thanks to ~jk-ozlabs, ~anthonywong, and ~vanhoof ]

This merge request adds a new AddCard method (thanks jk!), which allows you to automagically create cards based in input. I have also included a simple example of how to make this work for reference, although I have not had a chance to put together testcase for this yet.

We've been able to add 100+ cards on the fly while we're working out the details of how we feel about the board layout once populated.

[Brad Crittenden (bac)]

Hi Chris,

Thanks for picking up lp2kanban and adapting it for your needs. We've gotten a lot of use out of the tool and are glad to see others using it too.

Here are some comments on the code:

* The copy method added to LeankitCard is not used anywhere. If it isn't needed we should remove it. Let me know if you have a reason for keeping it.

* Yes, tests would be nice!

Overall it looks very good. I'll be glad to land the branch for you when I hear back.

review: Approve

[Anthony Wong (anthonywong)]

Hi Brad,

The copy method was added for card duplication. We use it in our team's script to duplicate cards in some scenarios. What we are doing is to create new cards that are based on an existing one, then modify some fields and save them. It's useful to us due to the lack of such a feature in LKK UI.

Thanks,
Anthony

[Chris Van Hoof (vanhoof)]

Thanks Anthony!

Brad if you could like an example of the card copy method, we could put one together similar to the add card example as well.

=== added file 'example_addcard_method.py'
--- example_addcard_method.py	1970-01-01 00:00:00 +0000
+++ example_addcard_method.py	2012-04-25 00:13:29 +0000
@@ -0,0 +1,29 @@
+# the directory containing the kanban.py file needs to be in your
+# PYTHONPATH
+import kanban
+import sys
+import os
+import json
+
+# these are the IDs of the lane and board that you want to
+# automagically add cards to
+BOARD_ID = 12345678
+LANE_ID = 23456789
+
+def main(args):
+  kb = kanban.LeankitKanban('canonical',
+                      '[e-mail]',
+                      'password')
+
+  board = kb.getBoard(board_id = BOARD_ID)
+  lane = board.getLane(LANE_ID)
+  #print lane.cards
+  card = lane.addCard()
+  card.title = 'automagic new card!'
+  card.size = '99'
+  card.external_card_id = '123456'
+  card.is_blocked = 'false'
+  card.save()
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv))

=== modified file 'example_config.ini'
--- example_config.ini	2011-08-08 10:08:02 +0000
+++ example_config.ini	2012-04-25 00:13:29 +0000
@@ -1,6 +1,6 @@
 [GLOBAL]
 # This is the account part of https://<account>.leankitkanban.com/ URL.
-account = launchpad
+account = canonical
 # LeankitKanban user name and password.
 user = [e-mail]
 password = password

=== modified file 'src/lp2kanban/kanban.py'
--- src/lp2kanban/kanban.py	2012-01-25 15:29:10 +0000
+++ src/lp2kanban/kanban.py	2012-04-25 00:13:29 +0000
@@ -163,12 +163,16 @@
 class LeankitUser(Converter):
     attributes = ['UserName', 'FullName', 'EmailAddress', 'Id']
 
+class LeankitCardType(Converter):
+    attributes = ['Name', 'IsDefault', 'ColorHex', 'IconPath', 'Id']
 
 class LeankitCard(Converter):
     attributes = ['Id', 'Title', 'Priority', 'Description', 'Tags',
-                  'TypeId', 'AssignedUserId']
+                  'TypeId']
 
-    optional_attributes = ['ExternalCardID']
+    optional_attributes = ['ExternalCardID', 'AssignedUserId', 'Size', 'IsBlocked',
+                           'BlockReason', 'ExternalSystemName', 'ExternalSystemUrl',
+                           'ClassOfServiceId', 'DueDate']
 
     def __init__(self, card_dict, lane):
         super(LeankitCard, self).__init__(card_dict)
@@ -177,6 +181,11 @@
         self.tags_list = set([tag.strip() for tag in self.tags.split(',')])
         if '' in self.tags_list:
             self.tags_list.remove('')
+        self.type = lane.board.cardtypes[self.type_id]
+
+    @property
+    def is_new(self):
+        return self.id is None
 
     def addTag(self, tag):
         tag = tag.strip()
@@ -186,7 +195,7 @@
             self.tags = ', '.join(self.tags_list)
 
     def save(self):
-        if not self.is_dirty:
+        if not (self.is_dirty or self.is_new):
             # no-op.
             return
         data = self._raw_data
@@ -199,15 +208,34 @@
         for attr in self.dirty_attrs:
             #print "Storing %s in %s..." % (attr, self._toCamelCase(attr))
             data[self._toCamelCase(attr)] = getattr(self, attr)
-        result = self.lane.board.connector.post(
-            '/Board/' + str(self.lane.board.id) + '/UpdateCard', data=data)
+
+        if self.is_new:
+            del data['Id']
+            del data['LaneId']
+            position = len(self.lane.cards)
+            url_parts = ['/Board', str(self.lane.board.id), 'AddCard',
+                         'Lane', str(self.lane.id), 'Position', str(position)]
+        else:
+            url_parts = ['/Board', str(self.lane.board.id), 'UpdateCard']
+
+        url = '/'.join(url_parts)
+
+        result = self.lane.board.connector.post(url, data=data)
+
+        if (self.is_new and
+                result.ReplyCode in LeankitResponseCodes.SUCCESS_CODES):
+            self.id = result.ReplyData[0]['CardId']
+
         return result.ReplyData[0]
 
     def move(self, target_lane):
         if target_lane is not None and target_lane != self.lane:
             self.lane = target_lane
             self._raw_data['LaneId'] = self.lane.id
-            return self._moveCard()
+            if not self.is_new:
+                return self._moveCard()
+            else:
+                return self.save()
         else:
             return None
 
@@ -225,6 +253,39 @@
                     self.title, self.id, target_lane.path) +
                 "Error %s: %s" % (result.ReplyCode, result.ReplyText))
 
+    @classmethod
+    def create(cls, lane):
+        default_card_data = {
+            'Id': None,
+            'Title': '',
+            'Priority': 1,
+            'Description': '',
+            'Tags': '',
+            'TypeId': lane.board.default_cardtype.id,
+            'LaneId': lane.id,
+            'IsBlocked': "false",
+            'BlockReason': None,
+            'ExternalCardID': None,
+            'ExternalSystemName': None,
+            'ExternalSystemUrl': None,
+            'ClassOfServiceId': None,
+        }
+        card = cls(default_card_data, lane)
+        return card
+
+    def copy(self, src):
+        self.title = src.title
+        self.priority = src.priority
+        self.description = src.description
+        self.tags = src.tags
+        self.type_id = src.type_id
+        self.lane = src.lane
+        self.is_blocked = src.is_blocked
+        self.size = src.size
+        self.block_reason = src.block_reason
+        self.due_date = src.due_date
+        self.external_card_id = src.external_card_id 
+        self.assigned_user_id = src.assigned_user_id
 
 class LeankitLane(Converter):
     attributes = ['Id', 'Title', 'Index', 'Orientation', 'ParentLaneId']
@@ -233,10 +294,10 @@
     def __init__(self, lane_dict, board):
         super(LeankitLane, self).__init__(lane_dict)
         self.parent_lane = None
+        self.board = board
+        self.child_lanes = []
         self.cards = [LeankitCard(card_data, self)
                       for card_data in lane_dict['Cards']]
-        self.board = board
-        self.child_lanes = []
 
     @property
     def path(self):
@@ -297,6 +358,10 @@
             return self._getNextLanes(self.parent_lane, self.index,
                                       self.orientation)
 
+    def addCard(self):
+        card = LeankitCard.create(self)
+        self.cards.append(card)
+        return card
 
 class LeankitBoard(Converter):
 
@@ -318,6 +383,7 @@
             }, self)
         self.lanes = { 0: self.root_lane }
         self.cards = []
+        self.default_cardtype = None
 
     def getCardsWithExternalIds(self):
         for card in self.cards:
@@ -329,6 +395,7 @@
             self.base_uri + str(self.id)).ReplyData[0]
 
         self._populateUsers(self.details['BoardUsers'])
+        self._populateCardTypes(self.details['CardTypes'])
         self._populateLanes(self.details['Lanes'])
 
     def _populateUsers(self, user_data):
@@ -354,6 +421,16 @@
             self.cards.extend(lane.cards)
         self._sortLanes()
 
+    def _populateCardTypes(self, cardtypes_data):
+        self.cardtypes = {}
+        for cardtype_dict in cardtypes_data:
+            cardtype = LeankitCardType(cardtype_dict)
+            self.cardtypes[cardtype.id] = cardtype
+            if cardtype.is_default:
+                self.default_cardtype = cardtype
+
+        assert self.default_cardtype is not None
+
     def _sortLanes(self, lane=None):
         """Sorts the root lanes and lists of child lanes by their index."""
         if lane is None:
@@ -363,6 +440,48 @@
         for lane in lanes:
             self._sortLanes(lane)
 
+    def getLane(self, lane_id):
+        flat_lanes = {}
+        def flatten_lane(lane):
+            flat_lanes[lane.id] = lane
+            for child in lane.child_lanes:
+                flatten_lane(child)
+        map(flatten_lane, self.root_lane.child_lanes)
+        return flat_lanes[lane_id];
+
+    def getLaneByTitle(self, title):
+        if len(self.root_lane.child_lanes) > 0:
+            return self._getLaneByTitle(self.root_lane, title)
+
+    def _getLaneByTitle(self, lane, title):
+        if (lane.title == title):
+            return lane
+        else:
+            for child in lane.child_lanes:
+                result = self._getLaneByTitle(child, title)
+                if result != None:
+                    return result
+            return None
+
+    def getLaneByPath(self, path, ignorecase=False):
+        if len(self.root_lane.child_lanes) > 0:
+            return self._getLaneByPath(self.root_lane, path, ignorecase)
+
+    def _getLaneByPath(self, lane, path, ignorecase):
+        if ignorecase == True:
+            if lane.path.lower() == path.lower():
+                return lane
+        else:
+            if lane.path == path:
+                return lane
+
+        for child in lane.child_lanes:
+            result = self._getLaneByPath(child, path, ignorecase)
+            if result != None:
+                return result
+        return None
+
+
     def _printLanes(self, lane, indent, include_cards=False):
         next_lane = lane.getNextLanes()
         if next_lane is None: