src/snek/app.py

@@ -1,4 +1,5 @@
 import pathlib
+from types import SimpleNamespace
 
 from aiohttp import web
 from aiohttp_session import (
@@ -13,15 +14,16 @@ from snek.docs.app import Application as DocsApplication
 from snek.mapper import get_mappers
 from snek.service import get_services
 from snek.system import http
-from snek.system.cache import Cache
 from snek.system.markdown import MarkdownExtension
 from snek.system.middleware import cors_middleware
 from snek.view.about import AboutHTMLView, AboutMDView
 from snek.view.docs import DocsHTMLView, DocsMDView
 from snek.view.index import IndexView
 from snek.view.login import LoginView
+from snek.view.login_form import LoginFormView
 from snek.view.logout import LogoutView
 from snek.view.register import RegisterView
+from snek.view.register_form import RegisterFormView
 from snek.view.status import StatusView
 from snek.view.web import WebView
 
@@ -51,9 +53,11 @@ class Application(BaseApplication):
         self._middlewares.append(session_middleware)
         self.jinja2_env.add_extension(MarkdownExtension)
         self.setup_router()
-        self.cache = Cache(self)
+        self.setup_services()
-        self.services = get_services(app=self)
+
-        self.mappers = get_mappers(app=self)
+    def setup_services(self):
+        self.services = SimpleNamespace(**get_services(app=self))
+        self.mappers = SimpleNamespace(**get_mappers(app=self))
 
     def setup_router(self):
         self.router.add_get("/", IndexView)
@@ -72,9 +76,9 @@ class Application(BaseApplication):
         self.router.add_view("/status.json", StatusView)
         self.router.add_view("/web.html", WebView)
         self.router.add_view("/login.html", LoginView)
-        self.router.add_view("/login.json", LoginView)
+        self.router.add_view("/login.json", LoginFormView)
         self.router.add_view("/register.html", RegisterView)
-        self.router.add_view("/register.json", RegisterView)
+        self.router.add_view("/register.json", RegisterFormView)
         self.router.add_get("/http-get", self.handle_http_get)
         self.router.add_get("/http-photo", self.handle_http_photo)
 

src/snek/mapper/__init__.py

@@ -1,22 +1,11 @@
 import functools
 
-from snek.mapper.channel import ChannelMapper
-from snek.mapper.channel_member import ChannelMemberMapper
-from snek.mapper.channel_message import ChannelMessageMapper
 from snek.mapper.user import UserMapper
-from snek.system.object import Object
 
 
 @functools.cache
 def get_mappers(app=None):
-    return Object(
+    return {"user": UserMapper(app=app)}
-        **{
-            "user": UserMapper(app=app),
-            "channel_member": ChannelMemberMapper(app=app),
-            "channel": ChannelMapper(app=app),
-            "channel_message": ChannelMessageMapper(app=app),
-        }
-    )
 
 
 def get_mapper(name, app=None):

src/snek/mapper/channel.py

@@ -1,7 +0,0 @@
-from snek.model.channel import ChannelModel
-from snek.system.mapper import BaseMapper
-
-
-class ChannelMapper(BaseMapper):
-    table_name = "channel"
-    model_class = ChannelModel

src/snek/mapper/channel_member.py

@@ -1,7 +0,0 @@
-from snek.model.channel_member import ChannelMemberModel
-from snek.system.mapper import BaseMapper
-
-
-class ChannelMemberMapper(BaseMapper):
-    table_name = "channel_member"
-    model_class = ChannelMemberModel

src/snek/mapper/channel_message.py

@@ -1,7 +0,0 @@
-from snek.model.channel_message import ChannelMessageModel
-from snek.system.mapper import BaseMapper
-
-
-class ChannelMessageMapper(BaseMapper):
-    model_class = ChannelMessageModel
-    table_name = "channel_message"

src/snek/model/__init__.py

@@ -1,24 +1,11 @@
 import functools
 
-from snek.model.channel import ChannelModel
-from snek.model.channel_member import ChannelMemberModel
-
-# from snek.model.channel_message import ChannelMessageModel
-from snek.model.channel_message import ChannelMessageModel
 from snek.model.user import UserModel
-from snek.system.object import Object
 
 
 @functools.cache
 def get_models():
-    return Object(
+    return {"user": UserModel}
-        **{
-            "user": UserModel,
-            "channel_member": ChannelMemberModel,
-            "channel": ChannelModel,
-            "channel_message": ChannelMessageModel,
-        }
-    )
 
 
 def get_model(name):

src/snek/model/channel.py

@@ -1,11 +0,0 @@
-from snek.system.model import BaseModel, ModelField
-
-
-class ChannelModel(BaseModel):
-    label = ModelField(name="label", required=True, kind=str)
-    description = ModelField(name="description", required=False, kind=str)
-    tag = ModelField(name="tag", required=False, kind=str)
-    created_by_uid = ModelField(name="created_by_uid", required=True, kind=str)
-    is_private = ModelField(name="is_private", required=True, kind=bool, value=False)
-    is_listed = ModelField(name="is_listed", required=True, kind=bool, value=True)
-    index = ModelField(name="index", required=True, kind=int, value=1000)

src/snek/model/channel_member.py

@@ -1,15 +0,0 @@
-from snek.system.model import BaseModel, ModelField
-
-
-class ChannelMemberModel(BaseModel):
-    label = ModelField(name="label", required=True, kind=str)
-    channel_uid = ModelField(name="channel_uid", required=True, kind=str)
-    user_uid = ModelField(name="user_uid", required=True, kind=str)
-    is_moderator = ModelField(
-        name="is_moderator", required=True, kind=bool, value=False
-    )
-    is_read_only = ModelField(
-        name="is_read_only", required=True, kind=bool, value=False
-    )
-    is_muted = ModelField(name="is_muted", required=True, kind=bool, value=False)
-    is_banned = ModelField(name="is_banned", required=True, kind=bool, value=False)

src/snek/model/channel_message.py

@@ -1,7 +0,0 @@
-from snek.system.model import BaseModel, ModelField
-
-
-class ChannelMessageModel(BaseModel):
-    channel_uid = ModelField(name="channel_uid", required=True, kind=str)
-    user_uid = ModelField(name="user_uid", required=True, kind=str)
-    message = ModelField(name="message", required=True, kind=str)

src/snek/model/notification.py

@@ -1,9 +0,0 @@
-from snek.system.model import BaseModel, ModelField
-
-
-class NotificationModel(BaseModel):
-    object_uid = ModelField(name="object_uid", required=True)
-    object_type = ModelField(name="object_type", required=True)
-    message = ModelField(name="message", required=True)
-    user_uid = ModelField(name="user_uid", required=True)
-    read_at = ModelField(name="is_read", required=True)

src/snek/model/user.py

@@ -10,13 +10,6 @@ class UserModel(BaseModel):
         max_length=20,
         regex=r"^[a-zA-Z0-9_]+$",
     )
-    nick = ModelField(
-        name="nick",
-        required=False,
-        min_length=2,
-        max_length=20,
-        regex=r"^[a-zA-Z0-9_]+$",
-    )
     email = ModelField(
         name="email",
         required=False,

src/snek/service/__init__.py

@@ -1,20 +1,12 @@
 import functools
 
-from snek.service.channel import ChannelService
-from snek.service.channel_member import ChannelMemberService
 from snek.service.user import UserService
-from snek.system.object import Object
 
 
 @functools.cache
 def get_services(app):
-    return Object(
+
-        **{
+    return {"user": UserService(app=app)}
-            "user": UserService(app=app),
-            "channel_member": ChannelMemberService(app=app),
-            "channel": ChannelService(app=app),
-        }
-    )
 
 
 def get_service(name, app=None):

src/snek/service/channel.py

@@ -1,48 +0,0 @@
-from snek.system.service import BaseService
-
-
-class ChannelService(BaseService):
-    mapper_name = "channel"
-
-    async def create(
-        self,
-        label,
-        created_by_uid,
-        description=None,
-        tag=None,
-        is_private=False,
-        is_listed=True,
-    ):
-        if label[0] != "#" and is_listed:
-            label = f"#{label}"
-        count = await self.count(deleted_at=None)
-        if not tag and not count:
-            tag = "public"
-        model = await self.new()
-        model["label"] = label
-        model["description"] = description
-        model["tag"] = tag
-        model["created_by_uid"] = created_by_uid
-        model["is_private"] = is_private
-        model["is_listed"] = is_listed
-        if await self.save(model):
-            return model
-        raise Exception(f"Failed to create channel: {model.errors}.")
-
-    async def ensure_public_channel(self, created_by_uid):
-        model = await self.get(is_listed=True, tag="public")
-        is_moderator = False
-        if not model:
-            is_moderator = True
-            model = await self.create(
-                "public", created_by_uid=created_by_uid, is_listed=True, tag="public"
-            )
-        await self.app.services.channel_member.create(
-            model["uid"],
-            created_by_uid,
-            is_moderator=is_moderator,
-            is_read_only=False,
-            is_muted=False,
-            is_banned=False,
-        )
-        return model

src/snek/service/channel_member.py

@@ -1,33 +0,0 @@
-from snek.system.service import BaseService
-
-
-class ChannelMemberService(BaseService):
-
-    mapper_name = "channel_member"
-
-    async def create(
-        self,
-        channel_uid,
-        user_uid,
-        is_moderator=False,
-        is_read_only=False,
-        is_muted=False,
-        is_banned=False,
-    ):
-        model = await self.get(channel_uid=channel_uid, user_uid=user_uid)
-        if model:
-            if model.is_banned.value:
-                return False
-            return model
-        model = await self.new()
-        channel = await self.services.channel.get(uid=channel_uid)
-        model["label"] = channel["label"]
-        model["channel_uid"] = channel_uid
-        model["user_uid"] = user_uid
-        model["is_moderator"] = is_moderator
-        model["is_read_only"] = is_read_only
-        model["is_muted"] = is_muted
-        model["is_banned"] = is_banned
-        if await self.save(model):
-            return model
-        raise Exception(f"Failed to create channel member: {model.errors}.")

src/snek/service/channel_message.py

@@ -1,14 +0,0 @@
-from snek.system.service import BaseService
-
-
-class ChannelMessageService(BaseService):
-    mapper_name = "channel_message"
-
-    async def create(self, channel_uid, user_uid, message):
-        model = await self.new()
-        model["channel_uid"] = channel_uid
-        model["user_uid"] = user_uid
-        model["message"] = message
-        if await self.save(model):
-            return model
-        raise Exception(f"Failed to create channel message: {model.errors}.")

src/snek/service/notification.py

@@ -1,37 +0,0 @@
-from snek.system.service import BaseService
-
-
-class NotificationService(BaseService):
-    mapper_name = "notification"
-
-    async def create(self, object_uid, object_type, user_uid, message):
-        model = await self.new()
-        model["object_uid"] = object_uid
-        model["object_type"] = object_type
-        model["user_uid"] = user_uid
-        model["message"] = message
-        if await self.save(model):
-            return model
-        raise Exception(f"Failed to create notification: {model.errors}.")
-
-    async def create_channel_message(self, channel_message_uid):
-        channel_message = await self.services.channel_message.get(
-            uid=channel_message_uid
-        )
-        user = await self.services.user.get(uid=channel_message["user_uid"])
-        async for channel_member in self.services.channel_member.find(
-            channel_uid=channel_message["channel_uid"],
-            is_banned=False,
-            is_muted=False,
-            deleted_at=None,
-        ):
-            model = await self.new()
-            model["object_uid"] = channel_message_uid
-            model["object_type"] = "channel_message"
-            model["user_uid"] = channel_member["user_uid"]
-            model["message"] = (
-                f"New message from {user['nick']} in {channel_member['label']}."
-            )
-            if await self.save(model):
-                return model
-            raise Exception(f"Failed to create notification: {model.errors}.")

src/snek/service/user.py

@@ -7,8 +7,10 @@ class UserService(BaseService):
 
     async def validate_login(self, username, password):
         model = await self.get(username=username)
+        print("FOUND USER!", model, flush=True)
         if not model:
             return False
+        print("AU", password, model.password.value, flush=True)
         if not await security.verify(password, model["password"]):
             return False
         return True
@@ -17,16 +19,9 @@ class UserService(BaseService):
         if await self.exists(username=username):
             raise Exception("User already exists.")
         model = await self.new()
-        model["nick"] = username
         model.email.value = email
         model.username.value = username
         model.password.value = await security.hash(password)
         if await self.save(model):
-            if model:
-                channel = await self.services.channel.ensure_public_channel(
-                    model["uid"]
-                )
-                if not channel:
-                    raise Exception("Failed to create public channel.")
             return model
         raise Exception(f"Failed to create user: {model.errors}.")

src/snek/system/cache.py

@@ -1,103 +1,7 @@
 import functools
-import json
-
-from snek.system import security
 
 cache = functools.cache
 
-CACHE_MAX_ITEMS_DEFAULT = 5000
-
-
-class Cache:
-    def __init__(self, app, max_items=CACHE_MAX_ITEMS_DEFAULT):
-        self.app = app
-        self.cache = {}
-        self.max_items = max_items
-        self.lru = []
-        self.version = ((42 + 420 + 1984 + 1990 + 10 + 6 + 71 + 3004 + 7245) ^ 1337) + 4
-
-    async def get(self, args):
-        try:
-            self.lru.pop(self.lru.index(args))
-        except:
-            print("Cache miss!", args, flush=True)
-            return None
-        self.lru.insert(0, args)
-        while len(self.lru) > self.max_items:
-            self.cache.pop(self.lru[-1])
-            self.lru.pop()
-        print("Cache hit!", args, flush=True)
-        return self.cache[args]
-
-    def json_default(self, value):
-        # if hasattr(value, "to_json"):
-        #    return value.to_json()
-        try:
-            return json.dumps(value.__dict__, default=str)
-        except:
-            return str(value)
-
-    async def create_cache_key(self, args, kwargs):
-        return await security.hash(
-            json.dumps(
-                {"args": args, "kwargs": kwargs},
-                sort_keys=True,
-                default=self.json_default,
-            )
-        )
-
-    async def set(self, args, result):
-        is_new = args not in self.cache
-        self.cache[args] = result
-        try:
-            self.lru.pop(self.lru.index(args))
-        except (ValueError, IndexError):
-            pass
-        self.lru.insert(0, args)
-
-        while len(self.lru) > self.max_items:
-            self.cache.pop(self.lru[-1])
-            self.lru.pop()
-
-        if is_new:
-            self.version += 1
-            print("New version:", self.version, flush=True)
-
-    async def delete(self, args):
-        if args in self.cache:
-            try:
-                self.lru.pop(self.lru.index(args))
-            except IndexError:
-                pass
-            del self.cache[args]
-
-    def async_cache(self, func):
-        @functools.wraps(func)
-        async def wrapper(*args, **kwargs):
-            cache_key = await self.create_cache_key(args, kwargs)
-            cached = await self.get(cache_key)
-            if cached:
-                return cached
-            result = await func(*args, **kwargs)
-            await self.set(cache_key, result)
-            return result
-
-        return wrapper
-
-    def async_delete_cache(self, func):
-        @functools.wraps(func)
-        async def wrapper(*args, **kwargs):
-            cache_key = await self.create_cache_key(args, kwargs)
-            if cache_key in self.cache:
-                try:
-                    self.lru.pop(self.lru.index(cache_key))
-                except IndexError:
-                    pass
-                del self.cache[cache_key]
-            return await func(*args, **kwargs)
-
-        return wrapper
-
 
 def async_cache(func):
     cache = {}

src/snek/system/mapper.py

@@ -54,10 +54,7 @@ class BaseMapper:
         if not kwargs.get("_limit"):
             kwargs["_limit"] = self.default_limit
         for record in self.table.find(**kwargs):
-            model = await self.new()
+            yield await self.model_class.from_record(mapper=self, record=record)
-            for key, value in record.items():
-                model[key] = value
-            yield model
 
     async def delete(self, kwargs=None) -> int:
         if not kwargs or not isinstance(kwargs, dict):

src/snek/system/object.py

@@ -1,13 +0,0 @@
-class Object:
-
-    def __init__(self, *args, **kwargs):
-        for arg in args:
-            if isinstance(arg, dict):
-                self.__dict__.update(arg)
-        self.__dict__.update(kwargs)
-
-    def __getitem__(self, key):
-        return self.__dict__[key]
-
-    def __setitem__(self, key, value):
-        self.__dict__[key] = value

src/snek/system/service.py

@@ -7,23 +7,14 @@ class BaseService:
 
     mapper_name: BaseMapper = None
 
-    @property
-    def services(self):
-        return self.app.services
-
     def __init__(self, app):
         self.app = app
-        self.cache = app.cache
         if self.mapper_name:
             self.mapper = get_mapper(self.mapper_name, app=self.app)
         else:
             self.mapper = None
 
-    async def exists(self, uid=None, **kwargs):
+    async def exists(self, **kwargs):
-        if uid:
-            if not kwargs and await self.cache.get(uid):
-                return True
-            kwargs["uid"] = uid
         return await self.count(**kwargs) > 0
 
     async def count(self, **kwargs):
@@ -32,30 +23,15 @@ class BaseService:
     async def new(self, **kwargs):
         return await self.mapper.new()
 
-    async def get(self, uid=None, **kwargs):
+    async def get(self, **kwargs):
-        if uid:
+        return await self.mapper.get(**kwargs)
-            if not kwargs:
-                result = await self.cache.get(uid)
-                if result:
-                    return result
-            kwargs["uid"] = uid
-
-        result = await self.mapper.get(**kwargs)
-        if result:
-            await self.cache.set(result["uid"], result)
-        return result
 
     async def save(self, model: UserModel):
         # if model.is_valid: You Know why not
-        if await self.mapper.save(model):
+        return await self.mapper.save(model) and True
-            await self.cache.set(model["uid"], model)
-            return True
-        errors = await model.errors
-        raise Exception(f"Couldn't save model. Errors: f{errors}")
 
     async def find(self, **kwargs):
-        async for model in self.mapper.find(**kwargs):
+        return await self.mapper.find(**kwargs)
-            yield model
 
     async def delete(self, **kwargs):
         return await self.mapper.delete(**kwargs)

src/snek/system/view.py

@@ -20,8 +20,8 @@ class BaseView(web.View):
     def db(self):
         return self.app.db
 
-    async def json_response(self, data, **kwargs):
+    async def json_response(self, data):
-        return web.json_response(data, **kwargs)
+        return web.json_response(data)
 
     @property
     def session(self):

src/snek/view/login.py

@@ -1,23 +1,18 @@
-from aiohttp import web
+from snek.form.register import RegisterForm
-
+from snek.system.view import BaseView
-from snek.form.login import LoginForm
-from snek.system.view import BaseFormView
 
 
-class LoginView(BaseFormView):
+class LoginView(BaseView):
-    form = LoginForm
 
     async def get(self):
-        if self.session.get("logged_in"):
+        return await self.render_template(
-            return web.HTTPFound("/web.html")
+            "login.html"
-        if self.request.path.endswith(".json"):
+        )  # web.json_response({"form": RegisterForm().to_json()})
-            return await super().get()
-        return await self.render_template("login.html")
 
-    async def submit(self, form):
+    async def post(self):
-        if await form.is_valid:
+        form = RegisterForm()
-            self.session["logged_in"] = True
+        form.set_user_data(await self.request.post())
-            self.session["username"] = form.username.value
+        print(form.is_valid())
-            self.session["uid"] = form.uid.value
+        return await self.render_template(
-            return {"redirect_url": "/web.html"}
+            "login.html", self.request
-        return {"is_valid": False}
+        )  # web.json_response({"form": RegisterForm().to_json()})

src/snek/view/register.py

@@ -1,26 +1,7 @@
-from aiohttp import web
+from snek.system.view import BaseView
-
-from snek.form.register import RegisterForm
-from snek.system.view import BaseFormView
 
 
-class RegisterView(BaseFormView):
+class RegisterView(BaseView):
-
-    form = RegisterForm
 
     async def get(self):
-        if self.session.get("logged_in"):
-            return web.HTTPFound("/web.html")
-        if self.request.path.endswith(".json"):
-            return await super().get()
         return await self.render_template("register.html")
-
-    async def submit(self, form):
-        result = await self.app.services.user.register(
-            form.email.value, form.username.value, form.password.value
-        )
-        self.request.session["uid"] = result["uid"]
-        self.request.session["username"] = result["username"]
-        self.request.session["logged_in"] = True
-
-        return {"redirect_url": "/web.html"}

src/snek/view/status.py

@@ -3,44 +3,11 @@ from snek.system.view import BaseView
 
 class StatusView(BaseView):
     async def get(self):
-
-        memberships = []
-        user = {}
-
-        if self.session.get("uid"):
-            user = await self.app.services.user.get(uid=self.session.get("uid"))
-            if not user:
-                return await self.json_response({"error": "User not found"}, status=404)
-            async for model in self.app.services.channel_member.find(
-                user_uid=self.session.get("uid"), deleted_at=None, is_banned=False
-            ):
-                channel = await self.app.services.channel.get(uid=model["channel_uid"])
-                memberships.append(
-                    {
-                        "name": channel["label"],
-                        "description": model["description"],
-                        "user_uid": model["user_uid"],
-                        "is_moderator": model["is_moderator"],
-                        "is_read_only": model["is_read_only"],
-                        "is_muted": model["is_muted"],
-                        "is_banned": model["is_banned"],
-                        "channel_uid": model["channel_uid"],
-                        "uid": model["uid"],
-                    }
-                )
-            user = {
-                "username": user["username"],
-                "email": user["email"],
-                "nick": user["nick"],
-                "uid": user["uid"],
-                "memberships": memberships,
-            }
-
         return await self.json_response(
             {
-                "user": user,
+                "status": "ok",
-                "cache": await self.app.cache.create_cache_key(
+                "username": self.session.get("username"),
-                    self.app.cache.cache, None
+                "logged_in": self.session.get("username") and True or False,
-                ),
+                "uid": self.session.get("uid"),
             }
         )