Merge pull request #367 from OpenBazaar/mail-notifications

SMTP Notifications

Author: cpacia

api/restapi.py

@@ -849,6 +849,14 @@ def set_settings(self, request):
             if resolver != get_value("CONSTANTS", "RESOLVER"):
                 set_value("CONSTANTS", "RESOLVER", resolver)
 
+            if "smtp_notifications" not in request.args:
+                request.args["smtp_notifications"] = ['false']
+
+            smtp_attrs = ["smtp_server", "smtp_sender", "smtp_recipient", "smtp_username", "smtp_password"]
+            for smtp_attr in smtp_attrs:
+                if smtp_attr not in request.args:
+                    request.args[smtp_attr] = ['']
+
             settings_list = settings.get()
             if "moderators" in request.args and settings_list is not None:
                 mod_json = settings_list[11]
@@ -871,7 +879,13 @@ def set_settings(self, request):
                 json.dumps(request.args["blocked"] if request.args["blocked"] != "" else []),
                 request.args["terms_conditions"][0],
                 request.args["refund_policy"][0],
-                json.dumps(request.args["moderators"] if request.args["moderators"] != "" else [])
+                json.dumps(request.args["moderators"] if request.args["moderators"] != "" else []),
+                1 if str_to_bool(request.args["smtp_notifications"][0]) else 0,
+                request.args["smtp_server"][0],
+                request.args["smtp_sender"][0],
+                request.args["smtp_recipient"][0],
+                request.args["smtp_username"][0],
+                request.args["smtp_password"][0]
             )
 
             request.write(json.dumps({"success": True}, indent=4))
@@ -913,7 +927,13 @@ def get_settings(self, request):
                 "refund_policy": "" if settings[10] is None else settings[10],
                 "resolver": get_value("CONSTANTS", "RESOLVER"),
                 "network_connection": nat_type,
-                "transaction_fee": TRANSACTION_FEE
+                "transaction_fee": TRANSACTION_FEE,
+                "smtp_notifications": True if settings[14] == 1 else False,
+                "smtp_server": settings[15],
+                "smtp_sender": settings[16],
+                "smtp_recipient": settings[17],
+                "smtp_username": settings[18],
+                "smtp_password": settings[19],
             }
             mods = []
             try:

db/datastore.py

@@ -10,7 +10,7 @@
 from protos import objects
 from protos.objects import Listings, Followers, Following
 from os.path import join
-from db.migrations import migration1, migration2, migration3
+from db.migrations import migration1, migration2, migration3, migration4
 
 
 class Database(object):
@@ -116,7 +116,7 @@ def _create_database(database_path):
         conn = lite.connect(database_path)
         cursor = conn.cursor()
 
-        cursor.execute('''PRAGMA user_version = 3''')
+        cursor.execute('''PRAGMA user_version = 4''')
         cursor.execute('''CREATE TABLE hashmap(hash TEXT PRIMARY KEY, filepath TEXT)''')
 
         cursor.execute('''CREATE TABLE profile(id INTEGER PRIMARY KEY, serializedUserInfo BLOB, tempHandle TEXT)''')
@@ -169,7 +169,9 @@ def _create_database(database_path):
 
         cursor.execute('''CREATE TABLE settings(id INTEGER PRIMARY KEY, refundAddress TEXT, currencyCode TEXT,
     country TEXT, language TEXT, timeZone TEXT, notifications INTEGER, shippingAddresses BLOB, blocked BLOB,
-    termsConditions TEXT, refundPolicy TEXT, moderatorList BLOB, username TEXT, password TEXT)''')
+    termsConditions TEXT, refundPolicy TEXT, moderatorList BLOB, username TEXT, password TEXT,
+    smtpNotifications INTEGER, smtpServer TEXT, smtpSender TEXT, smtpRecipient TEXT, smtpUsername TEXT,
+    smtpPassword TEXT)''')
 
         conn.commit()
         conn.close()
@@ -180,16 +182,21 @@ def _run_migrations(self):
         cursor.execute('''PRAGMA user_version''')
         version = cursor.fetchone()[0]
         conn.close()
+
         if version == 0:
             migration1.migrate(self.PATH)
             migration2.migrate(self.PATH)
             migration3.migrate(self.PATH)
+            migration4.migrate(self.PATH)
         elif version == 1:
             migration2.migrate(self.PATH)
             migration3.migrate(self.PATH)
+            migration4.migrate(self.PATH)
         elif version == 2:
             migration3.migrate(self.PATH)
-
+            migration4.migrate(self.PATH)
+        elif version == 3:
+            migration4.migrate(self.PATH)
 
 class HashMap(object):
     """
@@ -1244,16 +1251,19 @@ def __init__(self, database_path):
         self.PATH = database_path
 
     def update(self, refundAddress, currencyCode, country, language, timeZone, notifications,
-               shipping_addresses, blocked, terms_conditions, refund_policy, moderator_list):
+               shipping_addresses, blocked, terms_conditions, refund_policy, moderator_list, smtp_notifications,
+               smtp_server, smtp_sender, smtp_recipient, smtp_username, smtp_password):
         conn = Database.connect_database(self.PATH)
         with conn:
             cursor = conn.cursor()
             cursor.execute('''INSERT OR REPLACE INTO settings(id, refundAddress, currencyCode, country,
 language, timeZone, notifications, shippingAddresses, blocked, termsConditions,
-refundPolicy, moderatorList) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)''',
+refundPolicy, moderatorList, smtpNotifications, smtpServer, smtpSender,
+smtpRecipient, smtpUsername, smtpPassword) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)''',
                            (1, refundAddress, currencyCode, country, language, timeZone,
                             notifications, shipping_addresses, blocked, terms_conditions,
-                            refund_policy, moderator_list))
+                            refund_policy, moderator_list, smtp_notifications, smtp_server,
+                            smtp_sender, smtp_recipient, smtp_username, smtp_password))
             conn.commit()
         conn.close()
 

db/migrations/__init__.py

@@ -1 +1,2 @@
 __author__ = 'chris'
+__all__ = ['migration1', 'migration2', 'migration3', 'migration4']

db/migrations/migration4.py

@@ -0,0 +1,21 @@
+import sqlite3
+
+
+def migrate(database_path):
+    print "migrating to db version 4"
+    conn = sqlite3.connect(database_path)
+    conn.text_factory = str
+    cursor = conn.cursor()
+
+    # update settings table to include smtp server settings
+    cursor.execute('''ALTER TABLE settings ADD COLUMN "smtpNotifications" INTEGER''')
+    cursor.execute('''ALTER TABLE settings ADD COLUMN "smtpServer" TEXT''')
+    cursor.execute('''ALTER TABLE settings ADD COLUMN "smtpSender" TEXT''')
+    cursor.execute('''ALTER TABLE settings ADD COLUMN "smtpRecipient" TEXT''')
+    cursor.execute('''ALTER TABLE settings ADD COLUMN "smtpUsername" TEXT''')
+    cursor.execute('''ALTER TABLE settings ADD COLUMN "smtpPassword" TEXT''')
+
+    # update version
+    cursor.execute('''PRAGMA user_version = 4''')
+    conn.commit()
+    conn.close()

db/tests/test_datastore.py

@@ -335,12 +335,12 @@ def test_VendorStore(self):
         self.assertEqual(v, {})
 
     def test_Settings(self):
-        NUM_SETTINGS = 14
+        NUM_SETTINGS = 20
         settings = self.settings.get()
         self.assertIsNone(settings)
 
         self.settings.update('NEW_ADDRESS', 'BTC', 'AUSTRALIA', 'EN',
-                             '', '', '', '', '', '', '')
+                             '', '', '', '', '', '', '', '', '', '', '', '', '')
         settings = self.settings.get()
         self.assertEqual(NUM_SETTINGS, len(settings))
 

market/contracts.py

@@ -27,6 +27,7 @@
 from market.transactions import BitcoinTransaction
 from protos.countries import CountryCode
 from protos.objects import Listings
+from market.smtpnotification import SMTPNotification
 
 
 class Contract(object):
@@ -531,6 +532,13 @@ def accept_order_confirmation(self, notification_listener, confirmation_json=Non
             vendor_guid = self.contract["vendor_offer"]["listing"]["id"]["guid"]
             self.notification_listener.notify(vendor_guid, handle, "order confirmation", contract_hash, title,
                                               image_hash)
+
+            # Send SMTP notification
+            notification = SMTPNotification(self.db)
+            notification.send("[OpenBazaar] Order Confirmed and Shipped",
+                              "You have received an order confirmation.<br><br>"
+                              "Order: %s<br>Vendor: %s<br>Title: %s<br>" % (contract_hash, vendor_guid, title))
+
             return True
         except Exception, e:
             return e.message
@@ -747,6 +755,14 @@ def accept_receipt(self, notification_listener, blockchain, receipt_json=None):
 
         self.notification_listener.notify(buyer_guid, handle, "rating received", order_id, title, image_hash)
 
+        notification_rater = handle if handle else buyer_guid.encode('hex')
+
+        notification = SMTPNotification(self.db)
+        notification.send("[OpenBazaar] New Rating Received",
+                          "You received a new rating from %s for Order #%s - \"%s\". " % (notification_rater,
+                                                                                          order_id,
+                                                                                          title))
+
         if "rating" in self.contract["buyer_receipt"]["receipt"]:
             self.db.ratings.add_rating(self.contract["buyer_receipt"]["receipt"]
                                        ["rating"]["tx_summary"]["listing"],
@@ -803,9 +819,11 @@ def await_funding(self, notification_listener, libbitcoin_client, proofSig, is_p
                                            self.contract["vendor_offer"]["listing"]["metadata"]["category"])
         else:
             file_path = os.path.join(DATA_FOLDER, "store", "contracts", "unfunded", order_id + ".json")
+            title = self.contract["vendor_offer"]["listing"]["item"]["title"]
+            description = self.contract["vendor_offer"]["listing"]["item"]["description"]
             self.db.sales.new_sale(order_id,
-                                   self.contract["vendor_offer"]["listing"]["item"]["title"],
-                                   self.contract["vendor_offer"]["listing"]["item"]["description"],
+                                   title,
+                                   description,
                                    time.time(),
                                    self.contract["buyer_order"]["order"]["payment"]["amount"],
                                    payment_address,
@@ -814,6 +832,17 @@ def await_funding(self, notification_listener, libbitcoin_client, proofSig, is_p
                                    buyer,
                                    self.contract["vendor_offer"]["listing"]["metadata"]["category"])
 
+            try:
+                notification = SMTPNotification(self.db)
+                notification.send("[OpenBazaar] Order Received", "Order #%s<br>"
+                                                                 "Buyer: %s<br>"
+                                                                 "BTC Address: %s<br>"
+                                                                 "Title: %s<br>"
+                                                                 "Description: %s<br>"
+                                  % (order_id, buyer, payment_address, title, description))
+            except Exception as e:
+                self.log.info("Error with SMTP notification: %s" % e.message)
+
         with open(file_path, 'w') as outfile:
             outfile.write(json.dumps(self.contract, indent=4))
         self.blockchain.subscribe_address(str(payment_address), notification_cb=self.on_tx_received)
@@ -843,8 +872,8 @@ def on_tx_received(self, address_version, address_hash, height, block_hash, tx):
                 if self.amount_funded >= amount_to_pay:  # if fully funded
                     self.payment_received()
 
-        except Exception:
-            self.log.critical("Error processing bitcoin transaction")
+        except Exception as e:
+            self.log.critical("Error processing bitcoin transaction: %s" % e.message)
 
     def payment_received(self):
         self.blockchain.unsubscribe_address(
@@ -865,6 +894,14 @@ def payment_received(self):
             vendor_guid = self.contract["vendor_offer"]["listing"]["id"]["guid"]
             self.notification_listener.notify(unhexlify(vendor_guid), handle, "payment received",
                                               order_id, title, image_hash)
+
+            notification = SMTPNotification(self.db)
+            notification.send("[OpenBazaar] Purchase Payment Received", "Your payment was received.<br><br>"
+                                                                        "Order: %s<br>"
+                                                                        "Vendor: %s<br>"
+                                                                        "Title: %s"
+                              % (order_id, vendor_guid, title))
+
             # update the db
             if self.db.purchases.get_status(order_id) == 0:
                 self.db.purchases.update_status(order_id, 1)
@@ -880,6 +917,11 @@ def payment_received(self):
                 handle = ""
             self.notification_listener.notify(unhexlify(buyer_guid), handle, "new order", order_id,
                                               title, image_hash)
+
+            notification = SMTPNotification(self.db)
+            notification.send("[OpenBazaar] Payment for Order Received", "Payment was received for Order #%s."
+                              % order_id)
+
             self.db.sales.update_status(order_id, 1)
             self.db.sales.update_outpoint(order_id, json.dumps(self.outpoints))
             self.log.info("Received new order %s" % order_id)
@@ -1070,6 +1112,11 @@ def process_refund(self, refund_json, blockchain, notification_listener):
             handle = ""
         notification_listener.notify(buyer_guid, handle, "refund", order_id, title, image_hash)
 
+        notification = SMTPNotification(self.db)
+        notification.send("[OpenBazaar] Refund Received", "You received a refund.<br><br>"
+                                                          "Order: %s<br>Title: %s"
+                          % (order_id, title))
+
     def verify(self, sender_key):
         """
         Validate that an order sent over by a buyer is filled out correctly.

market/moderation.py

@@ -11,6 +11,7 @@
 from keys.keychain import KeyChain
 from market.contracts import Contract
 from protos.objects import PlaintextMessage
+from market.smtpnotification import SMTPNotification
 
 
 def process_dispute(contract, db, message_listener, notification_listener, testnet):
@@ -121,10 +122,20 @@ def process_dispute(contract, db, message_listener, notification_listener, testn
         raise Exception("Order ID for dispute not found")
 
     message_listener.notify(p, "")
+    title = contract["vendor_offer"]["listing"]["item"]["title"]
     notification_listener.notify(guid, handle, "dispute_open", order_id,
-                                 contract["vendor_offer"]["listing"]["item"]["title"],
+                                 title,
                                  unhexlify(contract["vendor_offer"]["listing"]["item"]["image_hashes"][0]))
 
+    # Send SMTP notification
+    notification = SMTPNotification(db)
+    guid = guid.encode("hex")
+    notification.send("[OpenBazaar] Dispute Opened",
+                      "A dispute has been opened.\n\n"
+                      "Order: %s\n"
+                      "Opened By: %s\n"
+                      "Title: %s" % (order_id, guid, title))
+
 
 def close_dispute(resolution_json, db, message_listener, notification_listener, testnet):
     """
@@ -183,6 +194,16 @@ def close_dispute(resolution_json, db, message_listener, notification_listener,
     p.avatar_hash = moderator_avatar
 
     message_listener.notify(p, "")
+    title = contract["vendor_offer"]["listing"]["item"]["title"]
     notification_listener.notify(moderator_guid, moderator_handle, "dispute_close", order_id,
-                                 contract["vendor_offer"]["listing"]["item"]["title"],
+                                 title,
                                  contract["vendor_offer"]["listing"]["item"]["image_hashes"][0])
+
+    # Send SMTP notification
+    notification = SMTPNotification(db)
+    guid = moderator_guid.encode("hex")
+    notification.send("[OpenBazaar] Dispute Closed",
+                      "A dispute has been closed.\n\n"
+                      "Order: %s\n"
+                      "Closed By: %s\n"
+                      "Title: %s" % (order_id, guid, title))

market/protocol.py

@@ -13,6 +13,7 @@
 from market.contracts import Contract
 from market.moderation import process_dispute, close_dispute
 from market.profile import Profile
+from market.smtpnotification import SMTPNotification
 from nacl.public import PublicKey, Box
 from net.rpcudp import RPCProtocol
 from protos.message import GET_CONTRACT, GET_IMAGE, GET_PROFILE, GET_LISTINGS, GET_USER_METADATA,\
@@ -157,6 +158,14 @@ def rpc_follow(self, sender, proto, signature):
                     listener.notify(sender.id, f.metadata.handle, "follow", "", "", f.metadata.avatar_hash)
                 except DoesNotImplement:
                     pass
+
+            # Send SMTP notification
+            notification = SMTPNotification(self.db)
+            notification.send("[OpenBazaar] %s is now following you!" % m.name,
+                              "You have a new follower:<br><br>Name: %s<br>GUID: <a href=\"ob://%s\">%s</a><br>"
+                              "Handle: %s" %
+                              (m.name, f.guid.encode('hex'), f.guid.encode('hex'), m.handle))
+
             return ["True", m.SerializeToString(), self.signing_key.sign(m.SerializeToString())[:64]]
         except Exception:
             self.log.warning("failed to validate follower")
@@ -315,8 +324,9 @@ def rpc_dispute_open(self, sender, pubkey, encrypted):
             self.router.addContact(sender)
             self.log.info("Contract dispute opened by %s" % sender)
             return ["True"]
-        except Exception:
+        except Exception as e:
             self.log.error("unable to parse disputed contract from %s" % sender)
+            self.log.error("Exception: %s" % e.message)
             return ["False"]
 
     def rpc_dispute_close(self, sender, pubkey, encrypted):