Merge pull request #411 from TotallyNotRobots/notes-cleanup

Clean up notes plugin

Author: linuxdaemon

plugins/notes.py

@@ -1,6 +1,8 @@
+"""
+Notes/todo list
+"""
 from datetime import datetime
 
-import sqlalchemy
 from sqlalchemy import (
     Boolean,
     Column,
@@ -9,6 +11,8 @@
     PrimaryKeyConstraint,
     String,
     Table,
+    and_,
+    func,
     not_,
 )
 from sqlalchemy.sql import select
@@ -30,41 +34,37 @@
 )
 
 
+def where_user(server, user):
+    """Generate a whereclause to match a user"""
+    return and_(
+        table.c.connection == server.lower(),
+        table.c.user == user.lower(),
+    )
+
+
 def read_all_notes(db, server, user, show_deleted=False):
-    if show_deleted:
-        query = (
-            select([table.c.note_id, table.c.text, table.c.added])
-            .where(table.c.connection == server)
-            .where(table.c.user == user.lower())
-            .order_by(table.c.added)
-        )
-    else:
-        query = (
-            select([table.c.note_id, table.c.text, table.c.added])
-            .where(table.c.connection == server)
-            .where(table.c.user == user.lower())
-            .where(not_(table.c.deleted))
-            .order_by(table.c.added)
-        )
+    query = select([table.c.note_id, table.c.text, table.c.added]).where(
+        where_user(server, user)
+    )
+
+    if not show_deleted:
+        query = query.where(not_(table.c.deleted))
+
+    query = query.order_by(table.c.added)
     return db.execute(query).fetchall()
 
 
 def delete_all_notes(db, server, user):
-    query = (
-        table.update()
-        .where(table.c.connection == server)
-        .where(table.c.user == user.lower())
-        .values(deleted=True)
-    )
+    query = table.update().where(where_user(server, user)).values(deleted=True)
+
     db.execute(query)
     db.commit()
 
 
 def read_note(db, server, user, note_id):
     query = (
         select([table.c.note_id, table.c.text, table.c.added])
-        .where(table.c.connection == server)
-        .where(table.c.user == user.lower())
+        .where(where_user(server, user))
         .where(table.c.note_id == note_id)
     )
     return db.execute(query).fetchone()
@@ -73,8 +73,7 @@ def read_note(db, server, user, note_id):
 def delete_note(db, server, user, note_id):
     query = (
         table.update()
-        .where(table.c.connection == server)
-        .where(table.c.user == user.lower())
+        .where(where_user(server, user))
         .where(table.c.note_id == note_id)
         .values(deleted=True)
     )
@@ -83,9 +82,9 @@ def delete_note(db, server, user, note_id):
 
 
 def add_note(db, server, user, text):
-    id_query = select(
-        [sqlalchemy.sql.expression.func.max(table.c.note_id).label("maxid")]
-    ).where(table.c.user == user.lower())
+    id_query = select([func.max(table.c.note_id).label("maxid")]).where(
+        where_user(server, user)
+    )
     max_id = db.execute(id_query).scalar()
 
     if max_id is None:
@@ -117,32 +116,32 @@ def format_note(data):
 
 
 @hook.command("note", "notes", "todo")
-def note(text, conn, nick, db, event):
+def note(text, db, event):
     """<add|list|get|del|clear> args - manipulates your list of notes"""
     notice = event.notice
     args, cmd = parse_args(text)
 
     if cmd in ["add", "new"]:
-        return cmd_add(args, conn, db, nick, notice)
+        return cmd_add(args, db, event)
 
     if cmd in ["del", "delete", "remove"]:
-        return cmd_del(args, conn, db, nick, notice)
+        return cmd_del(args, db, event)
 
     if cmd == "clear":
-        cmd_clear(conn, db, nick, notice)
+        cmd_clear(db, event)
         return None
 
     if cmd == "get":
-        return cmd_get(args, conn, db, nick, notice)
+        return cmd_get(args, db, event)
 
     if cmd in ["share", "show"]:
-        return cmd_show(args, conn, db, nick, notice)
+        return cmd_show(args, db, event)
 
     if cmd == "list":
-        return cmd_list(conn, db, nick, notice)
+        return cmd_list(db, event)
 
     if cmd == "listall":
-        return cmd_listall(conn, db, nick, notice)
+        return cmd_listall(db, event)
 
     notice("Unknown command: {}".format(cmd))
     return None
@@ -159,100 +158,94 @@ def parse_args(text):
     return args, cmd
 
 
-def cmd_clear(conn, db, nick, notice):
+def cmd_clear(db, event):
     # user is deleting all notes
-    delete_all_notes(db, conn.name, nick)
-    notice("All notes deleted!")
+    delete_all_notes(db, event.conn.name, event.nick)
+    event.notice("All notes deleted!")
 
 
-def cmd_listall(conn, db, nick, notice):
+def cmd_listall(db, event):
     # user is getting all notes including deleted ones
-    notes = read_all_notes(db, conn.name, nick, show_deleted=True)
+    notes = read_all_notes(db, event.conn.name, event.nick, show_deleted=True)
     if not notes:
-        notice("You have no notes.")
+        event.notice("You have no notes.")
         return None
 
-    notice("All notes for {}:".format(nick))
+    event.notice("All notes for {}:".format(event.nick))
     for n in notes:
         # show the note
         text = format_note(n)
-        notice(text)
+        event.notice(text)
 
     return None
 
 
-def cmd_list(conn, db, nick, notice):
+def cmd_list(db, event):
     # user is getting all notes
-    notes = read_all_notes(db, conn.name, nick)
+    notes = read_all_notes(db, event.conn.name, event.nick)
     if not notes:
-        notice("You have no notes.")
+        event.notice("You have no notes.")
         return None
 
-    notice("All notes for {}:".format(nick))
+    event.notice("All notes for {}:".format(event.nick))
     for n in notes:
         # show the note
         text = format_note(n)
-        notice(text)
+        event.notice(text)
 
     return None
 
 
-def cmd_show(args, conn, db, nick, notice):
+def cmd_show(args, db, event):
     # user is sharing a single note
     if not args:
-        return "No note ID provided!"
+        event.notice("No note ID provided!")
+        return None
+
     note_id = args[0]
-    n = read_note(db, conn.name, nick, note_id)
+    n = read_note(db, event.conn.name, event.nick, note_id)
     if not n:
-        notice("{} is not a valid note ID.".format(note_id))
+        event.notice("{} is not a valid note ID.".format(note_id))
         return None
 
     # show the note
     text = format_note(n)
     return text
 
 
-def cmd_get(args, conn, db, nick, notice):
+def cmd_get(args, db, event):
     # user is getting a single note
-    if not args:
-        return "No note ID provided!"
-    note_id = args[0]
-    n = read_note(db, conn.name, nick, note_id)
-    if not n:
-        notice("{} is not a valid note ID.".format(note_id))
-        return None
-
     # show the note
-    text = format_note(n)
-    notice(text)
-    return None
+    text = cmd_show(args, db, event)
+    if text is not None:
+        event.notice(text)
 
 
-def cmd_del(args, conn, db, nick, notice):
+def cmd_del(args, db, event):
     # user is deleting a note
     if not args:
         return "No note ID provided!"
 
     # but lets get the note first
     note_id = args[0]
-    n = read_note(db, conn.name, nick, note_id)
+    n = read_note(db, event.conn.name, event.nick, note_id)
     if not n:
-        notice("#{} is not a valid note ID.".format(note_id))
+        event.notice("#{} is not a valid note ID.".format(note_id))
         return None
 
     # now we delete it
-    delete_note(db, conn.name, nick, note_id)
-    notice("Note #{} deleted!".format(note_id))
+    delete_note(db, event.conn.name, event.nick, note_id)
+    event.notice("Note #{} deleted!".format(note_id))
     return None
 
 
-def cmd_add(args, conn, db, nick, notice):
-    # user is adding a note
+def cmd_add(args, db, event):
+    """user is adding a note"""
     if not args:
         return "No text provided!"
 
     note_text = " ".join(args)
     # add note to database
-    add_note(db, conn.name, nick, note_text)
-    notice("Note added!")
+    add_note(db, event.conn.name, event.nick, note_text)
+    event.notice("Note added!")
     return None