From dda86c460ad3e613bb0615102034c9826fb0921e Mon Sep 17 00:00:00 2001
From: Colin Swelin <cswelin@kineticcafe.com>
Date: Tue, 18 Oct 2016 16:44:44 -0400
Subject: [PATCH] Initial commit

---
 .gitignore                   |   1 +
 LICENSE                      |  21 +++++
 instructions.txt             |   1 +
 kevoPy/__init__.py           |   1 +
 kevoPy/kevopy.py             | 173 +++++++++++++++++++++++++++++++++++
 polykevo.py                  |  58 ++++++++++++
 polykevo_types.py            | 122 ++++++++++++++++++++++++
 polykevo_types0.py           |  99 ++++++++++++++++++++
 profile.zip                  | Bin 0 -> 1688 bytes
 profile/editor/editors.xml   |   7 ++
 profile/nls/en_us.txt        |  19 ++++
 profile/nodedef/nodedefs.xml |  34 +++++++
 profile/version.txt          |   1 +
 server.json                  |   8 ++
 zipprofile                   |   6 ++
 15 files changed, 551 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 LICENSE
 create mode 100644 instructions.txt
 create mode 100644 kevoPy/__init__.py
 create mode 100644 kevoPy/kevopy.py
 create mode 100644 polykevo.py
 create mode 100644 polykevo_types.py
 create mode 100644 polykevo_types0.py
 create mode 100644 profile.zip
 create mode 100755 profile/editor/editors.xml
 create mode 100755 profile/nls/en_us.txt
 create mode 100755 profile/nodedef/nodedefs.xml
 create mode 100755 profile/version.txt
 create mode 100644 server.json
 create mode 100755 zipprofile

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..35f8453
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+login.py
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..3f3d4c3
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Colin Swelin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/instructions.txt b/instructions.txt
new file mode 100644
index 0000000..80fd635
--- /dev/null
+++ b/instructions.txt
@@ -0,0 +1 @@
+https://github.com/cswelin/kevo-polyglot
diff --git a/kevoPy/__init__.py b/kevoPy/__init__.py
new file mode 100644
index 0000000..100ceca
--- /dev/null
+++ b/kevoPy/__init__.py
@@ -0,0 +1 @@
+from .kevopy import KevoPy
diff --git a/kevoPy/kevopy.py b/kevoPy/kevopy.py
new file mode 100644
index 0000000..ed9275f
--- /dev/null
+++ b/kevoPy/kevopy.py
@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+import requests
+import re
+import json
+import time
+
+from requests.packages.urllib3.exceptions import InsecureRequestWarning
+requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+
+class KevoPy(object):
+
+    _username = ''
+    _password = ''
+    _host = ''
+
+    _loginPath  = 'login'
+    _signinPath = 'signin'
+
+    _locks       = {}
+
+    def __init__(self, username, password, host='https://www.mykevo.com/'):
+
+        self._username   = username
+        self._password   = password
+
+        self._host       = host
+        self._session    = requests.Session()
+
+    def _reteiveToken(self):
+
+        response = self._session.get(self._host + self._loginPath, verify=False)
+        # response = self._session.get(self._host + self._loginPath, verify=False)
+        # print response
+        responseText = response.text
+
+        if response.url.endswith("user/locks"):
+            return
+
+        # print response.url
+        p = re.compile(r'input name="authenticity_token".*?value=\"(.*?)\"', re.MULTILINE | re.DOTALL)
+        values = re.findall(p, responseText)
+
+        self._token = values[0].strip()
+
+    def _praseLockIdentifiers(self,html):
+
+        p = re.compile(r'<div class=\'lock_unlock_container\' data-bolt-state=\'.*?\' data-lock-id=\'(.*?)\' id', re.MULTILINE | re.DOTALL)
+        # print html
+        values = re.findall(p, html)
+
+        # print html
+        for value in values:
+            kevo = KevoLock(value.strip(), self._session, self._host)
+            kevo.refresh()
+            self._locks[kevo.lock_id] = kevo
+
+    def connect(self):
+
+        self._reteiveToken()
+
+        r = self._session.post(self._host + self._signinPath,
+
+        data={"user[username]"      : self._username,
+             "user[password]"       : self._password,
+             "authenticity_token"   : self._token,
+             "commit"               : "Sign In",
+             "utf8"                 : "✓"})
+
+        self._praseLockIdentifiers(r.text)
+
+    def locks(self):
+        return self._locks.values()
+
+    def refreshAll(self):
+        for lock in self.locks():
+            lock.refresh()
+
+
+class KevoLock(object):
+
+    _lock_data  = {}
+    _unlock     = 'user/remote_locks/command/remote_unlock.json?arguments='
+    _lock       = 'user/remote_locks/command/remote_lock.json?arguments='
+    _info       = 'user/remote_locks/command/lock.json?arguments='
+    _session    = ''
+    _host       = ''
+
+    def __init__(self, lock_id, session, host):
+
+        self.lock_id = lock_id
+        self._session = session
+        self._host = host
+
+    def refresh(self):
+
+        r = self._session.get(self._host + self._info + self.lock_id)
+        self._lock_data =  json.loads(r.text)
+
+    def name(self):
+
+        return self._lock_data["name"]
+
+    def identifier(self):
+
+        return self._lock_data["id"]
+
+    def query(self):
+
+        return self._lock_data["bolt_state"]
+
+    def unlock(self):
+
+        try:
+
+            self._expected_state = "Unlocked"
+            self._previous_lock_state = self._lock_data["bolt_state"]
+
+            r = self._session.get(self._host + self._unlock + self.lock_id)
+            return self.verifyConfirmation()
+
+        except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError, TypeError) as e:
+
+            return False
+
+    def lock(self):
+
+        try:
+
+            self._expected_state = "Locked"
+            self._previous_lock_state = self._lock_data["bolt_state"]
+
+            r = self._session.get(self._host + self._lock + self.lock_id)
+            return self.verifyConfirmation()
+
+        except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError, TypeError) as e:
+
+            return False
+
+    def toggle(self):
+
+        if self.query() == "Unlocked":
+            self.lockLock()
+        else:
+            self.unlockLock()
+
+
+    def verifyConfirmation(self):
+
+        timeout = time.time() + 60*2
+        while self._expected_state != self._lock_data["bolt_state"]:
+
+            if time.time() > timeout:
+                return False
+
+            time.sleep(15)
+
+            self.refresh()
+
+        self.parent.update_driver()
+        return True
+
+
+def main():
+
+    kevo = KevoPy('user', 'pass')
+    kevo.connect()
+
+    for lock in kevo.locks():
+        print lock.query()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/polykevo.py b/polykevo.py
new file mode 100644
index 0000000..62b769e
--- /dev/null
+++ b/polykevo.py
@@ -0,0 +1,58 @@
+from polyglot.nodeserver_api import SimpleNodeServer, PolyglotConnector
+from polykevo_types import KevoDiscovery, KevoLock
+
+VERSION = "0.1.0"
+
+class KevoNodeServer(SimpleNodeServer):
+
+    controller = []
+    locks = []
+
+    def setup(self):
+        super(KevoNodeServer, self).setup()
+        manifest = self.config.get('manifest',{})
+
+        self.controller = KevoDiscovery(self,'disco','Kevo Discovery', True, manifest)
+        # self.poly.logger.info("FROM Poly ISYVER: " + self.poly.isyver)
+        self.controller.discover()
+        self.update_config()
+
+        # self.nodes['kevocontrol'].discover()
+
+    def poll(self):
+        self.poly.logger.info("poll")
+        if len(self.locks) >= 1:
+            self.controller.refreshAll()
+
+
+    def long_poll(self):
+        self.poly.logger.info("long_poll")
+        if len(self.locks) >= 1:
+            self.controller.refreshAll()
+
+
+    def report_drivers(self):
+        self.poly.logger.info("report_drivers")
+        # if len(self.controller.locks()) >= 1:
+        #     for i in self.locks:
+        #         i.report_driver()
+
+
+def main():
+
+    poly = PolyglotConnector()
+
+    nserver = KevoNodeServer(poly, 20, 40)
+    poly.connect()
+    poly.wait_for_config()
+
+    poly.logger.info("Kevo Interface version " + VERSION + "created")
+    nserver.setup()
+
+    poly.logger.info("Setup completed. Running Server.")
+
+    nserver.run()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/polykevo_types.py b/polykevo_types.py
new file mode 100644
index 0000000..afa2a5c
--- /dev/null
+++ b/polykevo_types.py
@@ -0,0 +1,122 @@
+from polyglot.nodeserver_api import Node
+from kevoPy import KevoPy
+from login import USERNAME, PASSWORD
+import hashlib
+
+class KevoDiscovery(Node):
+
+    def __init__(self, *args, **kwargs):
+        super(KevoDiscovery, self).__init__(*args, **kwargs)
+        self.kevo = KevoPy(USERNAME, PASSWORD)
+
+    def id_2_addr(self, udn):
+        ''' convert udn id to isy address '''
+        hasher = hashlib.md5()
+        hasher.update(udn)
+        return hasher.hexdigest()[0:14]
+
+    def discover(self, **kwargs):
+
+        manifest = self.parent.config.get('manifest', {})
+        self.parent.poly.logger.info("Discovering Kevo Locks...")
+        self.parent.poly.logger.info("User: %s", USERNAME)
+        self.kevo.connect()
+
+        self.parent.poly.logger.info("Found %d Locks", len(self.kevo.locks()))
+
+        if len(self.kevo.locks()) > 0:
+            for lock in self.kevo.locks():
+
+                name = lock.name()
+                address = self.id_2_addr(lock.identifier())
+
+                lnode = self.parent.get_node(address)
+                if not lnode:
+                    self.logger.info('Adding new Kevo Lock: %s(%s)', name, lock.lock_id)
+                    lock = KevoLock(self.parent, self.parent.get_node('disco'), address, lock, manifest)
+
+                    self.parent.locks.append(lock)
+                else:
+                    self.logger.info('Kevo Lock: %s(%s) already added', name, lock.lock_id)
+        else:
+            self.logger.info("No Locks found")
+
+        return True
+
+    def query(self, **kwargs):
+        self.parent.report_drivers()
+        return True
+
+    def refreshAll(self):
+        self.kevo.refreshAll()
+
+    _drivers = {}
+
+    _commands = {'NETDISCO': discover}
+
+    node_def_id = 'KEVODISCO'
+
+class KevoLock(Node):
+
+    def __init__(self, parent, primary, address, lock, manifest=None):
+
+        lock.parent = self
+        self.logger = parent.poly.logger
+        self.parent = parent
+        self.name = lock.name()
+        self.lock = lock
+        self.logger.info('Address: %s', address)
+        # super(KevoLock, self).__init__(parent, address, "Kevo " + lock.name(), primary, manifest)
+        super(KevoLock, self).__init__(parent, address, "Kevo " + lock.name(), primary, manifest)
+        self.logger.info('Initializing New Kevo Lock')
+        self.update_info()
+
+    def _setOn(self, **kwargs):
+
+        result = self.lock.lock()
+        if result == True:
+            self.report_driver()
+
+        return result
+
+    def _setOff(self, **kwargs):
+
+        result = self.lock.unlock()
+        if result == True:
+            self.report_driver()
+
+        return result
+
+
+    def _stateToUOM(self, state):
+        return {'Unlocked' : 0,
+                'Locked'   : 100,
+                'Unknown'  : 101,
+                'Bolt Jam' : 102,
+                'Processing' : 303,
+                'Confirming' : 304}[state]
+
+    def query(self, **kwargs):
+        self.update_info()
+        self.report_driver()
+        return True
+
+    def update_info(self):
+        self.lock.refresh()
+        self.update_driver()
+
+    def update_driver(self):
+        try:
+            self.logger.info("Setting ST to %d", self._stateToUOM(self.lock.query()))
+            self.set_driver('ST', self._stateToUOM(self.lock.query()))
+        except requests.exceptions.ConnectionError as e:
+            self.logger.error('Connection error to ISY: %s', e)
+
+
+    _drivers = {'ST': [0, 11, int]}
+
+    _commands = {'DON': _setOn,
+                 'DOF': _setOff,
+                 'ST' : query}
+
+    node_def_id = 'KEVO'
diff --git a/polykevo_types0.py b/polykevo_types0.py
new file mode 100644
index 0000000..0a62851
--- /dev/null
+++ b/polykevo_types0.py
@@ -0,0 +1,99 @@
+from polyglot.nodeserver_api import Node
+from kevoPy import KevoPy
+from login import USERNAME, PASSWORD
+
+class KevoDiscovery(Node):
+
+    def __init__(self, *args, **kwargs):
+        super(KevoDiscovery, self).__init__(*args, **kwargs)
+        self.kevo = KevoPy(USERNAME, PASSWORD)
+        self.kevo.logger = self.parent.poly.logger
+
+
+    def discover(self, **kwargs):
+
+        manifest = self.parent.config.get('manifest', {})
+        self.parent.poly.logger.info("Discovering Kevo Locks...")
+        self.parent.poly.logger.info("User: %s", USERNAME)
+        self.kevo.connect()
+
+        self.logger.info("Found %d Locks", len(self.kevo.locks()))
+
+        if len(self.kevo.locks()) > 0:
+            for lock in self.kevo.locks():
+                name = lock.name()
+                identifier = lock.identifier()[0:13]
+
+                lnode = self.parent.get_node(identifier)
+                if not lnode:
+                    self.logger.info('Adding new Kevo Lock: %s(%s)', name, lock.lock_id)
+                    self.parent.locks.append(KevoLock(self.parent, identifier, self.parent.get_node('KEVODISCO'), lock, manifest))
+                else:
+                    self.logger.info('Kevo Lock: %s(%s) already added', name, lock.lock_id)
+        else:
+            self.logger.info("No Locks found")
+
+        return True
+
+    def query(self, **kwargs):
+        self.parent.report_drivers()
+        return True
+
+    def refreshAll(self):
+        self.kevo.refreshAll()
+
+    _drivers = {}
+
+    _commands = {'NETDISCO': discover}
+
+    node_def_id = 'KEVODISCO'
+
+class KevoLock(Node):
+
+    def __init__(self, parent, address, primary, lock, manifest=None):
+
+        self.parent = parent
+        self.logger = self.parent.poly.logger
+        self.name = lock.name()
+        self.lock = lock
+
+        super(KevoLock, self).__init__(parent, address, "Kevo " + lock.name(), primary, manifest)
+
+        self.logger.info('Initializing New Kevo Lock')
+        self.update_info()
+
+    def _setOn(self, **kwargs):
+        self.lock.lock()
+
+    def _setOff(self, **kwargs):
+        self.lock.unlock()
+
+    def _stateToUOM(self, state):
+        return {'Unlocked' : 0,
+                'Locked'   : 100,
+                'Unknown'  : 101,
+                'Bolt Jam' : 102}[state]
+
+    def query(self, **kwargs):
+        self.update_info()
+        self.report_driver()
+        return True
+
+    def update_info(self):
+        try:
+            self.lock.refresh()
+            self.logger.info("Setting ST to %d", self._stateToUOM(self.lock.query()))
+            self.set_driver('ST', self._stateToUOM(self.lock.query()))
+        except requests.exceptions.ConnectionError as e:
+            self.logger.error('Connection error to ISY: %s', e)
+
+
+
+    _drivers = {'ST': [0, 11, int]}
+
+    _commands = {'DON': _setOn,
+                 'DOF': _setOff,
+                 'ST' : query,
+                 'QUERY': query}
+
+    node_def_id = 'KEVO'
diff --git a/profile.zip b/profile.zip
new file mode 100644
index 0000000000000000000000000000000000000000..76a6ebf7a9e25cf86713dbae2ce53462120a888d
GIT binary patch
literal 1688
zcmWIWW@h1H0D&9x9(jNnP=cL7h9Na2vn0PrKQx4sf!QOZB7D;v@rcq2ZU#n{uZ#=~
zEFwUq0YC#lGzY`!ig?dU&#p1%0(sMbSO{SN#GGQiirgHqS-R82Bg}yq&8*Fyz9)4~
z>T7L#9K^sR?HU`)`u@tMn$`!Cj!e3g#2OpBg2iQ~Q(D*BN!zn$)E9IJxiINOPMI-%
z-l~9E^Rri{WUN>c5Hl-ePE^wBlm*Ed42Rkra+WNaFg=*(q746)wF~%7Bjl4d$%>2j
zaF%d`9gf}SEI^0n<rEX??Y-6Uo@dVNJa!o9<u+ib@IrN`=Eav5>y=cLfPK7mws=G+
zX6ThpaO7?>5NUY-TeK<NadUQi0o$~^iO*usIGwS*apuMS@87&8E|~oJx7~L0*yk5|
z1RAAG?#z5}Pf;&b#kFwKO7(4#Z*o=?RAeXQeCgh(@pxVb_q-<)=Ll`tdex7sG+je6
z{@8MR&f?7Y-$t_5^V?s~RJG{&E9DS8TU@^HeEvNCs~-$De-NB|RrdBXqr(TbTl{Th
z+&Z^udDI2bOSM<Ocbj~1ZgJ-=P4-!x$Gy?5@&Ef<ukLZ}vewi)YNF)3Phhua4O?nH
zC;?y(M-EU(<fo*jq^1!WmJ5JMXiw?V7A;^n1~4-)h#;8&H3^Z3ZcoLUh}H(3&TBRh
z*z;L5`rU(=qLm7vtS()%n!GM~ScaY`6VXnHzTx@%Co3~=zsssCzsz<U|DLh+IO{@1
z+ZC;>S3k?iu*WTmWomq|OT^N`Z+2$qfsXv^Jq24ig`_LiNy(^uH1oYy=4>wHHA8GE
z)0J*b+ao&^UU5ltJxy^iy2z8P^|j;nRD<A|on?Vp{#!DXzFpY5vHjNFD!C(`5{?qO
z4+FZGp1tGgIPkowh}V7XQ)Q?5Z;sqCP8W|_rBlwa*T83Lw`-$>`j^vF-G45bd2Z$Y
z+2`%z=7(=IEPnDi>cQpO$<_b<9lEix|JIe8Ik_1uz6+(kw`MH(bG=z*V`l2Mxi<b%
zmr5)YO@(bv*Y0NOF~0kzA+KcB`W-Ls>^469Y1<a%J$v0>{^O57wyDlx>K``LnA56T
zv4;(qhC!Gc817}MMa7x<dGHhr%KupMtbv}Po)K4oHzSiAGxlV_&L9Ca5(ESo-a3M4
zc(K9?DOS*m0f=F^3KfW9zy!kZwh?3+)G(AH252s*h{0+uc1N<HIPw?JTu2E(*oBz+
zAK8T#K!<`%LMjb_MuJKM5*){Y;y5QJppo!wMc9FunF`r~El8%JW-*}2pe#nfov6tM
d+2lXK42+V9a5<F~l;jxLfzTT07<U#B4**<y{VM<f

literal 0
HcmV?d00001

diff --git a/profile/editor/editors.xml b/profile/editor/editors.xml
new file mode 100755
index 0000000..b130237
--- /dev/null
+++ b/profile/editor/editors.xml
@@ -0,0 +1,7 @@
+<editors>
+    <!-- Kevo Status -->
+    <editor id="KEVOST">
+        <range uom="11" subset="0,100,101,102" nls="KEVO_ST" />
+    </editor>
+
+</editors>
diff --git a/profile/nls/en_us.txt b/profile/nls/en_us.txt
new file mode 100755
index 0000000..0dd3d65
--- /dev/null
+++ b/profile/nls/en_us.txt
@@ -0,0 +1,19 @@
+# KevoControl
+ND-KEVOCONTROL-NAME = Kevo Disovery
+
+CMD-NETDISCO-NAME = Discover Locks
+CMD-DISCOVER-NAME = Discover Locks
+
+# KevoLock
+ND-KEVO-NAME = KEVO
+ND-KEVO-ICON = DoorLock
+ST-KEVO-ST-NAME = Status
+ST-KEVO-0 = Unlocked
+ST-KEVO-100 = Locked
+ST-KEVO-101 = Unknown
+ST-KEVO-102 = Jammed
+ST-KEVO-303 = Processing
+ST-KEVO-304 = Confirming
+
+CMD-KEVO-DON-NAME = Lock
+CMD-KEVO-DOF-NAME = Unlock
diff --git a/profile/nodedef/nodedefs.xml b/profile/nodedef/nodedefs.xml
new file mode 100755
index 0000000..131d9e9
--- /dev/null
+++ b/profile/nodedef/nodedefs.xml
@@ -0,0 +1,34 @@
+<nodeDefs>
+    <!-- KEVO Control -->
+    <nodeDef id="KEVODISCO" nls="KEVOCONTROL">
+        <editors />
+        <sts />
+        <cmds>
+            <sends />
+            <accepts>
+                <cmd id="DISCOVER" />
+            </accepts>
+        </cmds>
+    </nodeDef>
+    <!-- NODE DEF from 5.0 document http://wiki.universal-devices.com/index.php?title=V50_MAIN -->
+
+    <!-- KEVO Lock -->
+    <nodeDef id="KEVO" nls="KEVO">
+        <editors />
+        <sts>
+            <st id="ST" editor="KEVOST" />
+        </sts>
+        <cmds>
+            <sends />
+            <accepts>
+                <cmd id="DON" />
+<!--                  <p id="" editor="KEVOST" optional="T" init="ST" />
+                </cmd>-->
+                <cmd id="DOF" />
+                <cmd id="QUERY" />
+            </accepts>
+        </cmds>
+    </nodeDef>
+
+
+</nodeDefs>
diff --git a/profile/version.txt b/profile/version.txt
new file mode 100755
index 0000000..d917d3e
--- /dev/null
+++ b/profile/version.txt
@@ -0,0 +1 @@
+0.1.2
diff --git a/server.json b/server.json
new file mode 100644
index 0000000..fdc27f1
--- /dev/null
+++ b/server.json
@@ -0,0 +1,8 @@
+{
+    "name": "Kevo",
+    "docs": "https://www.universal-devices.com/",
+    "type": "python",
+    "executable": "polykevo.py",
+    "description": "Connect Kwikset kevo gateway system to the ISY994.",
+    "notice": "\"Kevo smart lock\" is a trademark owned by kwikset., see www.kwikset.com/kevo/smart-lock for more information. This Node Server is neither developed by nor endorsed by the kwikset organization."
+}
diff --git a/zipprofile b/zipprofile
new file mode 100755
index 0000000..79eda2b
--- /dev/null
+++ b/zipprofile
@@ -0,0 +1,6 @@
+#!/bin/bash
+rm profile.zip
+cd profile
+zip -r profile.zip *
+mv profile.zip ..
+cd ..