bashhub 3.0.2__py3-none-any.whl

bashhub/i_search.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+
+import npyscreen
+import datetime
+import time
+from . import rest_client
+import curses
+
+
+class CommandList(npyscreen.MultiLineAction):
+    def __init__(self, *args, **keywords):
+        super(CommandList, self).__init__(*args, **keywords)
+        self.command_handlers = {}
+
+        # Any non highlited command handlers
+        self.add_handlers({
+            "q": self.exit_app,
+            ord("n"): self.h_cursor_line_down,
+            ord("p"): self.h_cursor_line_up,
+            curses.ascii.ESC: self.exit_app
+        })
+
+        # All handlers for when a command is highlighted
+        self.add_command_handlers({
+            ord("i"): self.go_to_command_details,
+            curses.ascii.SP: self.go_to_command_details,
+            curses.ascii.NL: self.select_command,
+            curses.ascii.CR: self.select_command,
+            curses.ascii.BS: self.delete_command,
+            curses.ascii.DEL: self.delete_command,
+            curses.KEY_BACKSPACE: self.delete_command,
+            curses.KEY_DC: self.delete_command
+        })
+
+        # Disable handling of ALL mouse events right now. Without this we're
+        # unable to select text when inside of interactive search. This is
+        # convenient for access to the clipboard since on bash it'll
+        # automatically execute the command. Eventually find a way to allow this.
+        # It'd be nice to allow clicking to select a line.
+        curses.mousemask(0)
+
+    def delete_command(self, command):
+        confirmed = npyscreen.notify_ok_cancel(
+            str(command), "Delete Command")
+        if confirmed:
+            result = rest_client.delete_command(command.uuid)
+            if result:
+                self.parent.parentApp.commands.remove(command)
+                self.parent.update_list()
+
+    def exit_app(self, vl):
+        self.parent.parentApp.switchForm(None)
+
+    def display_value(self, vl):
+        return "{0}".format(vl)
+
+    def add_command_handlers(self, command_handlers):
+        self.command_handlers = command_handlers
+        # wire up to use npyscreens h_act_on_hightlited
+        event_handlers = dict((key, self.h_act_on_highlighted)
+                              for (key, value) in command_handlers.items())
+        self.add_handlers(event_handlers)
+
+    def actionHighlighted(self, command, keypress):
+        if keypress in self.command_handlers:
+            return self.command_handlers[keypress](command)
+
+    def go_to_command_details(self, command):
+        command_details = rest_client.get_command(command.uuid)
+        self.parent.parentApp.getForm('EDITRECORDFM').value = command_details
+        self.parent.parentApp.switchForm('EDITRECORDFM')
+
+    def select_command(self, command):
+        self.parent.parentApp.return_value = command
+        self.parent.parentApp.switchForm(None)
+
+
+class CommandListDisplay(npyscreen.FormMutt):
+    MAIN_WIDGET_CLASS = CommandList
+
+    #COMMAND_WIDGET_CLASS = None
+
+    def beforeEditing(self):
+        self.wStatus1.value = "Bashhub Commands "
+        self.update_list()
+
+    def update_list(self):
+        self.wMain.values = self.parentApp.commands
+        self.wMain.display()
+
+
+class EditRecord(npyscreen.ActionForm):
+    def __init__(self, *args, **keywords):
+        super(EditRecord, self).__init__()
+        self.add_handlers({
+            "q": self.previous_form,
+            curses.ascii.ESC: self.exit_app
+        })
+
+    def create(self):
+        self.value = None
+        self.command = self.add(npyscreen.TitleFixedText, name="Command:")
+        self.path = self.add(npyscreen.TitleFixedText, name="Path:")
+        self.created = self.add(npyscreen.TitleFixedText, name="Created At:")
+        self.exit_status = self.add(npyscreen.TitleFixedText,
+                                    name="Exit Status:")
+        self.system_name = self.add(npyscreen.TitleFixedText,
+                                    name="System Name:")
+        self.session_id = self.add(npyscreen.TitleFixedText,
+                                   name="Session Id:")
+        self.uuid = self.add(npyscreen.TitleFixedText, name="UUID:")
+
+    def exit_app(self, vl):
+        self.parentApp.switchForm(None)
+
+    def previous_form(self, vl):
+        self.parentApp.switchFormPrevious()
+
+    def beforeEditing(self):
+        if self.value:
+            record = self.value
+            self.name = "Command Details"
+            date_string = datetime.datetime.fromtimestamp(
+                record.created / 1000).strftime('%Y-%m-%d %H:%M:%S')
+            self.created.value = date_string
+            self.command.value = record.command
+            self.path.value = record.path
+
+            # Handle old commands that don't have exit status
+            exit_status = "None" if record.exit_status is None else str(
+                record.exit_status)
+            self.exit_status.value = exit_status
+
+            self.system_name.value = record.system_name
+            self.session_id.value = record.session_id
+            self.uuid.value = record.uuid
+
+        else:
+            self.command = "not found"
+
+    def on_ok(self):
+        self.parentApp.switchFormPrevious()
+
+    def on_cancel(self):
+        self.parentApp.switchFormPrevious()
+
+
+class InteractiveSearch(npyscreen.NPSAppManaged):
+    def __init__(self, commands, rest_client=None):
+        super(InteractiveSearch, self).__init__()
+        self.commands = commands
+        self.rest_client = rest_client
+        self.return_value = None
+
+    def onStart(self):
+        self.addForm("MAIN", CommandListDisplay)
+        self.addForm("EDITRECORDFM", EditRecord)

bashhub/interactive_search.py

@@ -0,0 +1,120 @@
+#!/usr/bin/python
+"""
+Sampled from Lyle Scott scrolling curses
+"""
+import curses
+import sys
+import random
+import time
+import locale
+
+
+class InteractiveSearch:
+    DOWN = 1
+    UP = -1
+    SPACE_KEY = 32
+    ESC_KEY = 27
+    ENTER_KEY = 10
+
+    PREFIX_SELECTED = '_X_'
+    PREFIX_DESELECTED = '___'
+
+    outputLines = []
+    commands = []
+    screen = None
+
+    def __init__(self, commands):
+
+        self.commands = commands
+        # Parse out our input
+        self.outputLines = [x.__str__() for x in commands]
+        self.nOutputLines = len(self.outputLines)
+
+        self.topLineNum = 0
+        self.highlightLineNum = 0
+        self.markedLineNums = []
+
+    def run(self):
+        # Locale set to support utf-8 characters.
+        locale.setlocale(locale.LC_ALL, "")
+        return curses.wrapper(self._run)
+
+    def _run(self, screen):
+        self.screen = screen
+        curses.cbreak()
+        curses.start_color()
+        curses.use_default_colors()
+        self.screen.border(0)
+        while True:
+            self.displayScreen()
+            # get user command
+            c = self.screen.getch()
+            if c == curses.KEY_UP or c == ord('k'):
+                self.updown(self.UP)
+            elif c == curses.KEY_DOWN or c == ord('j'):
+                self.updown(self.DOWN)
+            elif c == self.ENTER_KEY:
+                return self.selectLine()
+            elif c == self.ESC_KEY or c == ord('q'):
+                sys.exit()
+
+    def markLine(self):
+        linenum = self.topLineNum + self.highlightLineNum
+        if linenum in self.markedLineNums:
+            self.markedLineNums.remove(linenum)
+        else:
+            self.markedLineNums.append(linenum)
+
+    def selectLine(self):
+        linenum = self.topLineNum + self.highlightLineNum
+        self.screen.erase()
+        self.restoreScreen()
+        return self.commands[linenum]
+
+    def displayScreen(self):
+        # clear screen
+        self.screen.erase()
+
+        # now paint the rows
+        top = self.topLineNum
+        bottom = self.topLineNum + curses.LINES
+        for (index, line, ) in enumerate(self.outputLines[top:bottom]):
+            line = '%s' % (line, )
+
+            # highlight current line
+            if index != self.highlightLineNum:
+                self.screen.addstr(index, 0, line)
+            else:
+                self.screen.addstr(index, 0, line, curses.A_STANDOUT)
+        self.screen.refresh()
+
+    # move highlight up/down one line
+    def updown(self, increment):
+        nextLineNum = self.highlightLineNum + increment
+
+        # paging
+        if increment == self.UP and self.highlightLineNum == 0 and self.topLineNum != 0:
+            self.topLineNum += self.UP
+            return
+        elif increment == self.DOWN and nextLineNum == curses.LINES and (
+                self.topLineNum + curses.LINES) != self.nOutputLines:
+            self.topLineNum += self.DOWN
+            return
+
+        # scroll highlight line
+        if increment == self.UP and (self.topLineNum != 0 or
+                                     self.highlightLineNum != 0):
+            self.highlightLineNum = nextLineNum
+        elif increment == self.DOWN and (
+                self.topLineNum + self.highlightLineNum + 1
+        ) != self.nOutputLines and self.highlightLineNum != curses.LINES:
+            self.highlightLineNum = nextLineNum
+
+    def restoreScreen(self):
+        curses.nocbreak()
+        curses.echo()
+        curses.endwin()
+
+    # catch any weird termination situations
+    def __del__(self):
+        self.restoreScreen()

bashhub/model/__init__.py

@@ -0,0 +1,6 @@
+from .command import *
+from .command_form import *
+from .system import *
+from .min_command import MinCommand
+from .status_view import StatusView
+from .serializable import Serializable

bashhub/model/command.py

@@ -0,0 +1,55 @@
+#!/usr/bin/python
+from .min_command import MinCommand
+from time import *
+import jsonpickle
+import sys
+import uuid
+from .serializable import Serializable
+
+
+class Command(Serializable):
+    def __init__(self,
+                 command,
+                 path,
+                 uuid,
+                 username,
+                 system_name,
+                 session_id,
+                 created,
+                 id,
+                 exit_status=None):
+        self.command = command
+        self.path = path
+        self.uuid = uuid
+        self.exit_status = exit_status
+        self.username = username
+        self.system_name = system_name
+        self.session_id = session_id
+        self.created = created
+        self.id = id
+
+    # Optional fields not set by jsonpickle.
+    exit_status = None
+
+    def to_min_command(self):
+        return MinCommand(self.command, self.created, self.uuid)
+
+
+class RegisterUser(Serializable):
+    def __init__(self, email, username, password, registration_code=""):
+        self.email = email
+        self.username = username
+        self.password = password
+        self.registration_code = registration_code
+
+
+class LoginForm(Serializable):
+    def __init__(self, username, password, mac=None):
+        self.username = username
+        self.password = password
+        self.mac = mac
+
+
+class LoginResponse(Serializable):
+    def __init__(self, access_token):
+        self.access_token = access_token

bashhub/model/command_form.py

@@ -0,0 +1,15 @@
+from time import *
+import uuid
+from .serializable import Serializable
+
+
+class CommandForm(Serializable):
+    def __init__(self, command, path, exit_status, process_id,
+                 process_start_time):
+        self.uuid = uuid.uuid4().__str__()
+        self.command = command
+        self.path = path
+        self.exit_status = exit_status
+        self.process_id = int(process_id)
+        self.process_start_time = process_start_time
+        self.created = int(round(time() * 1000))

bashhub/model/min_command.py

@@ -0,0 +1,13 @@
+import json
+import requests
+from .serializable import Serializable
+
+
+class MinCommand(Serializable):
+    def __init__(self, command, created, uuid):
+        self.command = command
+        self.created = created
+        self.uuid = uuid
+
+    def __str__(self):
+        return self.command

bashhub/model/serializable.py

@@ -0,0 +1,47 @@
+import jsonpickle
+import json
+import requests
+import inflection
+
+
+class Serializable(object):
+    def to_JSON(self):
+        underscores = jsonpickle.encode(self)
+        temp = json.loads(underscores)
+        camel_case = self.convert_json(temp, self.lower_camelize)
+        return jsonpickle.encode(camel_case)
+
+    @classmethod
+    def lower_camelize(cls, string):
+        return inflection.camelize(string, False)
+
+    @classmethod
+    def convert_json(cls, d, convert):
+        new_d = {}
+        for k, v in d.items():
+            new_d[convert(k)] = cls.convert_json(v, convert) if isinstance(
+                v, dict) else v
+        return new_d
+
+    @classmethod
+    def from_JSON(cls, response):
+        temp_camel_case = json.loads(response)
+        temp = cls.convert_json(temp_camel_case, inflection.underscore)
+
+        # Add back our python classname so jsonpickle
+        # knows what class to deserialize it as
+        class_name = cls.__module__ + '.' + cls.__name__
+        temp['py/object'] = class_name
+
+        pickle = json.dumps(temp)
+        return jsonpickle.decode(pickle)
+
+    @classmethod
+    def from_JSON_list(cls, response):
+
+        #response = json.load(response)
+
+        # Use list comprehension to map every json object
+        # back to its object with from_JSON
+        items = [cls.from_JSON(json.dumps(item)) for item in response]
+        return items

bashhub/model/status_view.py

@@ -0,0 +1,15 @@
+from .serializable import Serializable
+
+
+class StatusView(Serializable):
+    def __init__(self, username, total_commands, total_sessions, total_systems,
+                 total_commands_today, session_name, session_start_time,
+                 session_total_commands):
+        self.username = username
+        self.total_commands = total_commands
+        self.total_sessions = total_sessions
+        self.total_systems = total_systems
+        self.total_commands_today = total_commands_today
+        self.session_name = session_name
+        self.session_start_time = session_start_time
+        self.session_total_commands = session_total_commands

bashhub/model/system.py

@@ -0,0 +1,42 @@
+import jsonpickle
+import json
+import requests
+from .serializable import Serializable
+
+
+class System(Serializable):
+    def __init__(self, name, mac, id, created, updated, hostname,
+                 client_version):
+        self.name = name
+        self.mac = mac
+        self.id = id
+        self.created = created
+        self.updated = updated
+        self.hostname = hostname
+        self.client_version = client_version
+
+    def __str__(self):
+        return self.name + " " + self.id
+
+
+class RegisterSystem(Serializable):
+    def __init__(self, name, mac, hostname, client_version):
+        self.name = name
+        self.mac = mac
+        self.hostname = hostname
+        self.client_version = client_version
+
+
+class SystemPatch(Serializable):
+    def __init__(self,
+                 name=None,
+                 mac=None,
+                 hostname=None,
+                 client_version=None):
+        self.name = name
+        self.mac = mac
+        self.hostname = hostname
+        self.client_version = client_version
+
+    def __str__(self):
+        return self.name + " " + self.mac