Install button.

src/snek/static/app.js

@@ -298,6 +298,10 @@ class Socket extends EventHandler {
         })
     }
     onData(data) {
+        if(data.success != undefined && !data.success){
+            console.error(data)
+        }
+
         if (data.callId) {
             this.emit(data.callId, data.data)
         }

src/snek/static/chat-window.js

@@ -22,14 +22,7 @@ class ChatWindowElement extends HTMLElement {
         
         const chatHeader = document.createElement("div")
         chatHeader.classList.add("chat-header")
-        let installPrompt = null 
+        
-        window.addEventListener("beforeinstallprompt", async(event) => {
-            event.preventDefault();
-            installPrompt = event;
-            const result = await installPrompt.prompt()
-            console.info(result.outcome)
-            //installButton.removeAttribute("hidden");
-          });
         
         
         const chatTitle = document.createElement('h2')

src/snek/templates/web.html

@@ -35,9 +35,28 @@
         <li><a href="#">Development</a></li>
         <li><a href="#">Support</a></li>
         <li><a href="#">Random</a></li>
+       
       </ul>
+      <fancy-button id="install-button" style="display:none" text="Install">Install</fancy-button>
     </aside>
     <chat-window class="chat-area"></chat-window>
   </main>
+  <script>
+let installPrompt = null 
+        window.addEventListener("beforeinstallprompt", async(event) => {
+            event.preventDefault();
+            installPrompt = event;
+            //document.addEventListener("DOMContentLoaded", () => {
+           
+            const button = document.getElementById("install-button")
+            button.addEventListener("click", async ()=>{  
+            const result = await installPrompt.prompt()
+            console.info(result.outcome)
+            })
+            button.style.display = 'block'
+            
+          });
+        ;
+    </script>
 </body>
 </html>

src/snek/view/rpc.py

@@ -4,26 +4,60 @@ from snek.system.view import BaseView
 
 class RPCView(BaseView):
 
-    login_required = True
-
     class RPCApi:
         def __init__(self,view, ws):
             self.view = view 
             self.app = self.view.app
             self.services = self.app.services
-            self.user_uid = self.view.session.get("uid")
             self.ws = ws 
+
+        @property
+        def user_uid(self):
+            return self.view.session.get("uid")
             
+
+        @property 
+        def request(self):
+            return self.view.request 
+        
+        def _require_login(self):
+            if not self.is_logged_in:
+                raise Exception("Not logged in")
+
+        @property 
+        def is_logged_in(self):
+            return self.view.session.get("logged_in", False)
+
+        async def login(self, username, password):
+            success = await self.services.user.validate_login(username, password)
+            if not success:
+                raise Exception("Invalid username or password")
+            user = await self.services.user.get(username=username)
+            self.view.session["uid"] = user["uid"]
+            self.view.session["logged_in"] = True
+            self.view.session["username"] = user["username"]
+            self.view.session["user_nick"] = user["nick"]
+            record = user.record
+            del record['password']
+            del record['deleted_at']
+            await self.services.socket.add(self.ws)
+            async for subscription in self.services.channel_member.find(user_uid=self.view.request.session.get("uid"),deleted_at=None,is_banned=False):
+                await self.services.socket.subscribe(self.ws,subscription["channel_uid"])
+       
+            return record 
         async def get_user(self, user_uid):
+            self._require_login()
             if not user_uid:
                 user_uid = self.user_uid
             user = await self.services.user.get(uid=user_uid)
             record = user.record
             del record['password']
             del record['deleted_at']
-            del record['email']
+            if not user_uid == user["uid"]:
+                del record['email']
             return record 
         async def get_messages(self, channel_uid,offset=0):
+            self._require_login()
             messages = []
             async for message in self.services.channel_message.query("SELECT * FROM channel_message ORDER BY created_at DESC LIMIT 60"): #"SELECT uid, channel_uid, user_uid, message, created_at FROM channel_message WHERE channel_uid = :channel_uid ORDER BY created_at DESC LIMIT 30 OFFSET :offset",{"channel_uid":channel_uid,"offset":int(offset)}):
                 
@@ -44,6 +78,7 @@ class RPCView(BaseView):
             return messages
         
         async def get_channels(self):
+            self._require_login()
             channels = []
             async for subscription in self.services.channel_member.find(user_uid=self.user_uid,is_banned=False):
                 channels.append(dict(
@@ -55,11 +90,13 @@ class RPCView(BaseView):
             return channels
 
         async def send_message(self, room, message):
+            self._require_login()
             await self.services.chat.send(self.user_uid,room,message)
             return True 
         
 
         async def echo(self,*args):
+            self._require_login()
             return args
 
 
@@ -67,16 +104,21 @@ class RPCView(BaseView):
 
 
         async def __call__(self, data):
-            call_id = data.get("callId")
+            try:
-            method_name = data.get("method")
+                call_id = data.get("callId")
-            args = data.get("args")
+                method_name = data.get("method")
-            if hasattr(super(),method_name) or not hasattr(self,method_name):
+                if method_name.startswith("_"):
-                return await self.ws.send_json({"callId":call_id,"data":"Not allowed"})
+                    raise Exception("Not allowed")
-
+                args = data.get("args")
-            method = getattr(self,method_name.replace(".","_"),None)
+                if hasattr(super(),method_name) or not hasattr(self,method_name):
-            result = await method(*args)
+                    return await self.ws.send_json({"callId":call_id,"data":"Not allowed"})
-            await self.ws.send_json({"callId":call_id,"data":result})
+                method = getattr(self,method_name.replace(".","_"),None)
-
+                if not method:
+                    raise Exception("Method not found")
+                result = await method(*args)
+                await self.ws.send_json({"callId":call_id,"success":True,"data":result})
+            except Exception as ex:
+                await self.ws.send_json({"callId":call_id,"success":False,"data":str(ex)})
 
     async def call_ping(self,callId,*args):
         return {"pong": args}
@@ -87,9 +129,10 @@ class RPCView(BaseView):
         
         ws = web.WebSocketResponse()
         await ws.prepare(self.request)
-        await self.services.socket.add(ws)
+        if self.request.session.get("logged_in") is True:
-        async for subscription in self.services.channel_member.find(user_uid=self.session.get("uid"),deleted_at=None,is_banned=False):
+            await self.services.socket.add(ws)
-            await self.services.socket.subscribe(ws,subscription["channel_uid"])
+            async for subscription in self.services.channel_member.find(user_uid=self.request.session.get("uid"),deleted_at=None,is_banned=False):
+                await self.services.socket.subscribe(ws,subscription["channel_uid"])
             print("Subscribed for: ", subscription["label"],flush=True)
         rpc = RPCView.RPCApi(self,ws)
         async for msg in ws: