Complete kv commands

royalgames.py

@@ -10,7 +10,8 @@ from royalnet.database.tables import Royal, Telegram
 loop = asyncio.get_event_loop()
 
 commands = [PingCommand, ShipCommand, SmecdsCommand, ColorCommand, CiaoruoziCommand, DebugCreateCommand, SyncCommand,
-            AuthorCommand, DiarioCommand, RageCommand, DateparserCommand, ReminderCommand, KvactiveCommand, KvCommand]
+            AuthorCommand, DiarioCommand, RageCommand, DateparserCommand, ReminderCommand, KvactiveCommand, KvCommand,
+            KvrollCommand]
 
 master = RoyalnetServer("localhost", 1234, "sas")
 tg_bot = TelegramBot(os.environ["TG_AK"], "localhost:1234", "sas", commands, os.environ["DB_PATH"], Royal, Telegram, "tg_id", error_command=ErrorHandlerCommand)

royalnet/commands/__init__.py

@@ -12,8 +12,9 @@ from .author import AuthorCommand
 from .reminder import ReminderCommand
 from .kvactive import KvactiveCommand
 from .kv import KvCommand
+from .kvroll import KvrollCommand
 
 
 __all__ = ["NullCommand", "PingCommand", "ShipCommand", "SmecdsCommand", "CiaoruoziCommand", "ColorCommand",
            "SyncCommand", "DiarioCommand", "RageCommand", "DateparserCommand", "AuthorCommand", "ReminderCommand",
-           "KvactiveCommand", "KvCommand"]
+           "KvactiveCommand", "KvCommand", "KvrollCommand"]

royalnet/commands/kv.py

@@ -1,22 +1,24 @@
-from ..database.tables import ActiveKvGroup, Royal, Keyvalue
+from ..database.tables import ActiveKvGroup, Royal, Keyvalue, Keygroup
 from ..utils import Command, Call, asyncify
 
 
 class KvCommand(Command):
 
     command_name = "kv"
-    command_description = "Visualizza o modifica un valore rv."
+    command_description = "Visualizza o modifica un valore kv."
-    command_syntax = "(nomegruppo)"
+    command_syntax = "(chiave) [valore]"
 
-    require_alchemy_tables = {ActiveKvGroup, Royal, Keyvalue}
+    require_alchemy_tables = {ActiveKvGroup, Royal, Keyvalue, Keygroup}
 
     @classmethod
     async def common(cls, call: Call):
-        key = call.args[0]
+        key = call.args[0].lower()
         value = call.args.optional(1)
         author = await call.get_author(error_if_none=True)
         active = await asyncify(call.session.query(call.alchemy.ActiveKvGroup).filter_by(royal=author).one_or_none)
-        keyvalue = await asyncify(call.session.query(call.alchemy.Keyvalue).filter_by(group=active.group_name, key=key).one_or_none)
+        if active is None:
+            await call.reply("⚠️ Devi prima attivare un gruppo con il comando [c]kvactive[/c]!")
+        keyvalue = await asyncify(call.session.query(call.alchemy.Keyvalue).filter_by(group=active.group, key=key).one_or_none)
         if value is None:
             # Get
             if keyvalue is None:
@@ -24,9 +26,9 @@ class KvCommand(Command):
                 return
             await call.reply(f"ℹ️ Valore della chiave:\n{keyvalue}")
         else:
-            # Set
+            # Set/kv asdf 1000
             if keyvalue is None:
-                keyvalue = call.alchemy.Keyvalue(group=active, key=key, value=value)
+                keyvalue = call.alchemy.Keyvalue(group=active.group, key=key, value=value)
                 call.session.add(keyvalue)
             else:
                 keyvalue.value = value

royalnet/commands/kvactive.py

@@ -1,4 +1,4 @@
-from ..database.tables import ActiveKvGroup, Royal
+from ..database.tables import ActiveKvGroup, Royal, Keygroup
 from ..utils import Command, Call, asyncify
 
 
@@ -16,9 +16,17 @@ class KvactiveCommand(Command):
         author = await call.get_author(error_if_none=True)
         active = await asyncify(call.session.query(call.alchemy.ActiveKvGroup).filter_by(royal=author).one_or_none)
         if active is None:
-            active = call.alchemy.ActiveKvGroup(royal=author, group=group_name)
+            group = await asyncify(call.session.query(call.alchemy.Keygroup).filter_by(group_name=group_name).one_or_none)
+            if group is None:
+                group = call.alchemy.Keygroup(group_name=group_name)
+                call.session.add(group)
+            active = call.alchemy.ActiveKvGroup(royal=author, group=group)
             call.session.add(active)
         else:
-            active.group = group_name
+            group = await asyncify(call.session.query(call.alchemy.Keygroup).filter_by(group_name=group_name).one_or_none)
+            if group is None:
+                group = call.alchemy.Keygroup(group_name=group_name)
+                call.session.add(group)
+            active.group = group
         await asyncify(call.session.commit)
         await call.reply(f"✅ Hai attivato il gruppo [b]{group_name}[/b].")

royalnet/commands/kvroll.py

@@ -0,0 +1,39 @@
+import random
+from ..database.tables import ActiveKvGroup, Royal, Keygroup, Keyvalue
+from ..utils import Command, Call, asyncify, plusformat
+
+
+class KvrollCommand(Command):
+
+    command_name = "kvroll"
+    command_description = "Lancia 1d20, poi aggiungici il valore della kv selezionata."
+    command_syntax = "(chiave) [modifier]"
+
+    require_alchemy_tables = {ActiveKvGroup, Royal, Keyvalue, Keygroup}
+
+    @classmethod
+    async def common(cls, call: Call):
+        key = call.args[0].lower()
+        normal_mod_str = call.args.optional(1, 0)
+        try:
+            normal_modifier = int(normal_mod_str)
+        except ValueError:
+            await call.reply("⚠️ Il modificatore specificato non è un numero.")
+            return
+        author = await call.get_author(error_if_none=True)
+        active = await asyncify(call.session.query(call.alchemy.ActiveKvGroup).filter_by(royal=author).one_or_none)
+        if active is None:
+            await call.reply("⚠️ Devi prima attivare un gruppo con il comando [c]kvactive[/c]!")
+            return
+        keyvalue = await asyncify(call.session.query(call.alchemy.Keyvalue).filter_by(group=active.group, key=key).one_or_none)
+        if keyvalue is None:
+            await call.reply("⚠️ La chiave specificata non esiste.")
+            return
+        try:
+            kv_modifier = int(keyvalue.value)
+        except ValueError:
+            await call.reply("⚠️ Il valore della chiave specificata non è un numero.")
+            return
+        roll = random.randrange(1, 21)
+        result = roll + kv_modifier + normal_modifier
+        await call.reply(f"🎲 {roll}{plusformat(kv_modifier)}{plusformat(normal_modifier)} = [b]{result}[/b]")

royalnet/database/tables/__init__.py

@@ -4,5 +4,6 @@ from .diario import Diario
 from .aliases import Alias
 from .activekvgroup import ActiveKvGroup
 from .keyvalue import Keyvalue
+from .keygroup import Keygroup
 
-__all__ = ["Royal", "Telegram", "Diario", "Alias", "ActiveKvGroup", "Keyvalue"]
+__all__ = ["Royal", "Telegram", "Diario", "Alias", "ActiveKvGroup", "Keyvalue", "Keygroup"]

royalnet/database/tables/keygroup.py

@@ -10,4 +10,3 @@ class Keygroup:
 
     def __repr__(self):
         return f"<Keygroup {self.group_name}>"
-

royalnet/database/tables/keyvalue.py

@@ -1,17 +1,21 @@
 from sqlalchemy import Column, \
                        String, \
                        ForeignKey
+from sqlalchemy.orm import relationship
+from .keygroup import Keygroup
 
 
 class Keyvalue:
     __tablename__ = "keyvalues"
 
-    group = Column(String, ForeignKey("keygroups.group_name"), primary_key=True)
+    group_name = Column(String, ForeignKey("keygroups.group_name"), primary_key=True)
     key = Column(String, primary_key=True)
     value = Column(String, nullable=False)
 
+    group = relationship("Keygroup")
+
     def __repr__(self):
-        return f"<Keyvalue group={self.group} key={self.key} value={self.value}>"
+        return f"<Keyvalue group={self.group_name} key={self.key} value={self.value}>"
 
     def __str__(self):
         return f"{self.key}: [b]{self.value}[/b]"

royalnet/utils/__init__.py

@@ -4,6 +4,7 @@ from .command import Command, CommandArgs, InvalidInputError, UnsupportedError,
 from .safeformat import safeformat
 from .classdictjanitor import cdj
 from .sleepuntil import sleep_until
+from .plusformat import plusformat
 
 __all__ = ["asyncify", "Call", "Command", "safeformat", "InvalidInputError", "UnsupportedError", "CommandArgs",
-           "cdj", "InvalidConfigError", "ExternalError", "sleep_until", "UnregisteredError"]
+           "cdj", "InvalidConfigError", "ExternalError", "sleep_until", "UnregisteredError", "plusformat"]

royalnet/utils/command.py

@@ -43,11 +43,11 @@ class CommandArgs(list):
             raise InvalidInputError("Pattern didn't match")
         return match
 
-    def optional(self, index: int) -> typing.Optional:
+    def optional(self, index: int, default=None) -> typing.Optional:
         try:
             return self[index]
-        except IndexError:
+        except InvalidInputError:
-            return None
+            return default
 
 
 class Command:

royalnet/utils/plusformat.py

@@ -0,0 +1,4 @@
+def plusformat(i: int) -> str:
+    if i >= 0:
+        return f"+{i}"
+    return str(i)