Payments deal with any Addressable object

Instead of carrying around a username and an address, manipulate payment
orders with an Addressable object until the last moment (serialization in
the database).

Note: we could use sqlite3 adapters to transparently read/write an
addressable object from/to the database.

Author: davux

bitcoim/command.py

@@ -37,15 +37,13 @@ def parse(line):
 class Command(object):
     '''A command that is sent to the component.'''
 
-    def __init__(self, action, arguments=[], target=None, username=''):
-        '''Constructor. action is the command to perform. arguments is an array
-           of words, target is the involved Address if any, and username is
-           the involved username if any.
-        '''
+    def __init__(self, action, arguments=[], target=None):
+        '''Constructor. action is the command to perform. arguments is an
+           array of words or phrases, target is the Addressable object the
+           command is targetted at.'''
         self.action = action.lower()
         self.arguments = arguments
         self.target = target
-        self.username = username
 
     def usage(self):
         """Return an explanation message about how to use the command. Raise an
@@ -67,14 +65,14 @@ def execute(self, user):
         """Actually execute the command, on behalf of the given user."""
         debug("A command was sent: %s" % self.action)
         if COMMAND_PAY == self.action:
-            if (self.target is None) and (0 == len(self.username)):
+            if self.target is None:
                 raise CommandTargetError, 'You can only send coins to a user or an address.'
             try:
                 amount = self.arguments.pop(0)
             except IndexError:
                 raise CommandSyntaxError, 'You must specify an amount.'
             comment = ' '.join(self.arguments)
-            return self._executePay(user, amount, self.target, self.username, comment)
+            return self._executePay(user, amount, self.target, comment)
         elif COMMAND_CANCEL == self.action:
             try:
                 code = self.arguments.pop(0)
@@ -98,23 +96,23 @@ def execute(self, user):
         else:
             raise UnknownCommandError, self.action
 
-    def _executePay(self, sender, amount, address, username, comment=''):
+    def _executePay(self, sender, amount, target, comment=''):
         """Called internally. Actually place the payment order in the pending
            list and generate the reply."""
-        debug("Pay order (BTC %s to %s from %s, %s)" % (amount, address, sender, comment))
+        debug("Pay order (BTC %s to %s from %s, %s)" % (amount, target, sender, comment))
         try:
             amount = int(amount)
         except ValueError:
             raise CommandSyntaxError, 'The amount must be a number.'
         if amount <= 0:
             raise CommandSyntaxError, 'The amount must be positive.'
         try:
-            order = PaymentOrder(sender, address, username, amount, comment)
+            order = PaymentOrder(sender, target, amount, comment)
         except PaymentToSelfError:
             raise CommandSyntaxError, 'You know, I\'m your own address. It doesn\'t make sense.'
         order.queue()
-        info("Payment order valid, queued: %s -> %s/%s (BTC %s, %s)" % \
-             (sender, address, username, amount, order.code))
+        info("Payment order valid, queued: %s -> %s (BTC %s, %s)" % \
+             (sender, target, amount, order.code))
         reply = "You want to pay BTC %s to %s" % (amount, order.recipient)
         if 0 != len(comment):
             reply += ' (%s)' % comment
@@ -159,11 +157,7 @@ def _executeCancel(self, user, code=None):
         debug("Payment %s (BTC %s to %s) was cancelled by %s" % \
               (code, payment.amount, payment.recipient, user))
         target = self.target
-        if self.target is not None:
-            target = self.target.address
-        elif 0 != len(self.username):
-            target = self.username
-        if target == payment.recipient:
+        if target == payment.target:
             reply = "Cancelled payment of BTC %s to me" % payment.amount
             if 0 != len(payment.comment):
                 reply += " (%s)" % payment.comment
@@ -203,27 +197,20 @@ def _executeConfirm(self, user, code=None):
     def _executeListPending(self, user):
         """Called internally. Generate the listing of all pending payments."""
         reply = ''
-        if self.target is not None:
-            label = "Pending payments to this address:"
-            empty = "No pending payments to this address."
-            for row in user.pendingPayments(self.target.address):
-                reply += "\n[%s] (%s): BTC %s" % (row['confirmation_code'], row['date'].date().isoformat(), row['amount'])
-                if 0 != len(row['comment']):
-                    reply += ' (%s)' % row['comment']
-        elif 0 != len(self.username):
-            label = "Pending payments to this user:"
-            empty = "No pending payments to this user."
-            for row in user.pendingPayments(self.username):
-                reply += "\n[%s] (%s): BTC %s" % (row['confirmation_code'], row['date'].date().isoformat(), row['amount'])
-                if 0 != len(row['comment']):
-                    reply += ' (%s)' % row['comment']
-        else:
+        if self.target is None:
             label = "Pending payments:"
             empty = "No pending payments."
             for row in user.pendingPayments():
                 reply += "\n[%s] (%s): BTC %s to %s" % (row['confirmation_code'], row['date'].date().isoformat(), row['amount'], row['recipient'])
                 if 0 != len(row['comment']):
                     reply += ' (%s)' % row['comment']
+        else:
+            label = "Pending payments to me:"
+            empty = "No pending payments to me."
+            for row in user.pendingPayments(self.target):
+                reply += "\n[%s] (%s): BTC %s" % (row['confirmation_code'], row['date'].date().isoformat(), row['amount'])
+                if 0 != len(row['comment']):
+                    reply += ' (%s)' % row['comment']
         if 0 == len(reply):
             return empty
         else:

bitcoim/paymentorder.py

@@ -1,4 +1,4 @@
-from bitcoin.address import Address
+from bitcoin.address import Address, InvalidBitcoinAddressError
 from bitcoin.controller import Controller
 from datetime import datetime
 from db import SQL
@@ -10,22 +10,25 @@
 class PaymentOrder(object):
     '''A payment order.'''
 
-    def __init__(self, sender, address=None, username='', amount=None, comment='', fee=0, code=None):
+    def __init__(self, sender, target=None, amount=None, comment='', fee=0, code=None):
+        from useraccount import UserAccount
         self.sender = sender
-        self.recipient = None
-        if (address is not None) and (0 != len(username)):
-            raise InvalidPaymentError, 'You cannot give an address and a username'
-        if address is not None:
-            if sender.ownsAddress(address):
+        self.target = target
+        if isinstance(target, Address):
+            if sender.ownsAddress(target):
                 raise PaymentToSelfError
-            self.recipient = address.address
-        elif 0 != len(username):
-            if sender.username == username:
+            self.recipient = target.address
+        elif isinstance(target, UserAccount):
+            if sender == target:
                 raise PaymentToSelfError
-            self.recipient = username
+            if 0 == len(target.username):
+                raise InvalidPaymentError, 'This user doesn\'t accept direct payments.'
+            self.recipient = target.username
+        else:
+            self.recipient = None
         if code is None:
-            if (address is None) and (0 == len(username)):
-                raise InvalidPaymentError, 'An address or a username must be given'
+            if self.recipient is None:
+                raise InvalidPaymentError, 'A recipient or an existing payment code must be given'
             self.amount = amount
             self.comment = comment
             self.fee = fee
@@ -59,6 +62,11 @@ def __init__(self, sender, address=None, username='', amount=None, comment='', f
             else:
                 (self.entryId, self.date, self.recipient, self.amount, \
                  self.comment, self.fee) = tuple(paymentOrder)
+            try:
+                self.target = Address(self.recipient)
+            except InvalidBitcoinAddressError:
+                # may raise UnknownUserError
+                self.target = UserAccount(self.recipient)
 
     @staticmethod
     def genConfirmationCode(length=4, alphabet='abcdefghjkmnpqrstuvwxyz23456789'):

bitcoim/useraccount.py

@@ -241,16 +241,19 @@ def isAdmin(self, newValue=None):
         else:
             self._isAdmin = newValue
 
-    def pendingPayments(self, recipient=None):
-        '''List all pending payments of the user. If a recipient is given, only
-           list pending payments to that recipient.'''
+    def pendingPayments(self, target=None):
+        '''List all pending payments of the user. If a valid target is given,
+           only list pending payments to that target.'''
         req = "select %s, %s, %s, %s, %s from %s where %s=?" % \
               ('date', 'recipient', 'amount', 'comment', 'confirmation_code', \
                'payments', 'from_jid')
         values = [self.jid]
-        if recipient is not None:
+        if isinstance(target, UserAccount):
             req += " and %s=?" % ('recipient')
-            values.append(recipient)
+            values.append(target.username)
+        elif isinstance(target, Address):
+            req += " and %s=?" % ('recipient')
+            values.append(target.address)
         SQL().execute(req, tuple(values))
         return SQL().fetchall()
 
@@ -319,7 +322,7 @@ def iqReceived(self, cnx, iq):
     def messageReceived(self, cnx, msg):
         from command import parse as parseCommand, Command
         (action, args) = parseCommand(msg.getBody())
-        command = Command(action, args, username=self.username)
+        command = Command(action, args, self)
         msg = msg.buildReply(command.execute(UserAccount(msg.getFrom())))
         msg.setType('chat')
         cnx.send(msg)