def setUp(self): self._db = Database(logger, True) new_api_key = binascii.hexlify(os.urandom(8)).decode('utf-8').upper() node_id = self._db.create_api_key(new_api_key) self.assertGreater(node_id, 0) self.api_key = new_api_key self.node_id = node_id
class TestCreateAPIKey(unittest.TestCase): def setUp(self): self._db = Database(logger, True) def test_add_key(self): new_api_key = binascii.hexlify(os.urandom(8)).decode('utf-8').upper() result = self._db.create_api_key(new_api_key) self.assertGreater(result, 0) def test_invalid_api_key(self): result = self._db.create_api_key("invalid") self.assertEqual(result, -1) def test_custom_reset_interval(self): new_api_key = binascii.hexlify(os.urandom(8)).decode('utf-8').upper() result = self._db.create_api_key(new_api_key, next_reset_seconds=5000) self.assertGreater(result, 0) api_key_info = self._db.validate_api_key(new_api_key) lower_bounds = 4995 higher_bounds = 5005 self.assertGreater(api_key_info[3], datetime.now() + timedelta(seconds=lower_bounds)) self.assertLess(api_key_info[3], datetime.now() + timedelta(seconds=higher_bounds)) self.assertEqual(result, api_key_info[0])
def setUp(self) -> None: # my default development environment values dev = Environment("localhost", "localhost", "pico", "password", "picoevent", "picoevent_test_db", 1000, 3600, "localhost", "localhost") self._db = Database(env=dev) self._event_log = EventLog(self._db) self._event_type_ids = self._event_log.list_event_types()
def setUp(self): self._db = Database(logger, True) self._target_api_keys = random.randint(5, 100) self._api_keys = [] for x in range(0, self._target_api_keys): new_api_key = binascii.hexlify( os.urandom(8)).decode('utf-8').upper() result = self._db.create_api_key(new_api_key) self.assertGreater(result, 0) self._api_keys.append(new_api_key)
class TestCreateEventType(unittest.TestCase): def setUp(self): self._db = Database(logger, True) def test_create_event_type(self): result = self._db.create_event_type("Node Update Event") self.assertGreater(result, 0) def test_create_event_type_db_fault(self): result = self._db.create_event_type("a" * 60) self.assertEqual(-1, result)
class TestListEventTypes(unittest.TestCase): def setUp(self): self._db = Database(logger, True) for each in DEFAULT_EVENTS: self._db.create_event_type(each) def test_list_event_types(self): event_types = self._db.list_event_types() all_events = [] for event in event_types: all_events.append(event[1]) result = set(DEFAULT_EVENTS) - set(all_events) self.assertEqual(0, len(result))
class TestAdminLogin(unittest.TestCase): def setUp(self): self._db = Database(logger, True) def test_admin_login(self): result = self._db.login("admin", "test_password") self.assertIsNotNone(result) new_session_token = result[0] admin_user_id = result[1] admin_user = self._db.validate_session(new_session_token) self.assertEqual(admin_user.user_id, admin_user_id) self.assertEqual(admin_user.session_token, new_session_token) self.assertEqual(admin_user.email_address, "admin") self.assertEqual(admin_user.full_name, "Administrator")
def __init__(self, db=None, logger=None): self._cache = redis.Redis() if db: self._db = db else: self._db = Database(logger) self._logger = logger event_types = [] for each in self.list_event_types(): event_types.append(each[1]) missing_events = set(DEFAULT_EVENTS) - set(event_types) for new_event in missing_events: self._db.create_event_type(new_event)
class TestDatabaseNotFoundException(unittest.TestCase): MAX_EVENTS_LOGGED = 1000 def setUp(self) -> None: self._db = Database(logger, True) self._mock_data = dict() total_events = random.randint(0, self.MAX_EVENTS_LOGGED) for each in DEFAULT_EVENTS: event_type_id = self._db.create_event_type(each) self.assertGreater(event_type_id, 0, msg="Failed to create event type") mock_events = [] now = datetime.now() for x in range(0, total_events): mock_event_data = { "floatMock": random.random(), "datetimeMock": random_later_datetime().isoformat(), "integerMock": random.randint(0, 1500000), "stringMock": "a" * random.randint(0, 1024) } new_mock_event = Event(0, event_type_id, each, mock_event_data, 0, 1, now) mock_events.append(new_mock_event) self._mock_data[each] = mock_events event_type = random.choice(DEFAULT_EVENTS) mock_events = self._mock_data[event_type] event_type_id = None for each_mock in mock_events: if event_type_id is None: event_type_id = each_mock.event_type_id event_id = self._db.log_event(each_mock.event_data, each_mock.event_type_id, each_mock.node_id, each_mock.user_id) self.assertGreater(event_id, 0, msg="Failed to log event.") each_mock.event_id = event_id event_type_count = self._db.get_event_count( event_type_id=event_type_id) self.assertEqual(event_type_count, len(mock_events)) logger.info("Events logged: {0} ({1})".format(event_type_count, event_type)) def test_lookupFailed(self): with self.assertRaises(DatabaseNotFoundException): self._db.get_event_data(self.MAX_EVENTS_LOGGED + self.MAX_EVENTS_LOGGED)
def admin_create_api_key(): with current_app.app_context(): environment = Environment(current_app) session_token = request.form["token"] db = Database(logger=current_app.logger, env=environment) analyst_user = db.validate_session(session_token) if analyst_user and analyst_user.has_permission("create-api-key"): new_api_key = binascii.hexlify(os.urandom(8)).decode('utf-8').upper() result = db.create_api_key(new_api_key) if result == -1: flash("Could not create API key.", category="error") return redirect(url_for("admin.home", session_token=session_token)) else: abort(403)
def change_administrator_password(self): _db = Database(self._logger, False, False, self._env) admin_uid = _db.admin_user_id if admin_uid > 0: new_password = input("New administrator password: "******"admin", new_password) except DatabaseException: print( "Database exception: unable to reset administrators password." ) else: print( "Invalid administrator user ID, database could be corrupted.") print( "Consider creating a new empty database and starting over.\n")
def post_event(api_key): with current_app.app_context(): environment = Environment(current_app) db = Database(logger=current_app.logger, env=environment) event_log = EventLog(db, logger=current_app.logger) try: node = event_log.get_api_key_object(api_key) event_log.update_quota(node) posted_data = request.get_json(force=True) if "event_type_id" in posted_data: event_type_id = int(posted_data["event_type_id"]) if event_type_id in event_log.event_type_ids_as_set: node_id = node.node_id user_id = None if "user_id" in posted_data and posted_data["user_id"] is not None: user_id = int(posted_data["user_id"]) del posted_data["user_id"] if user_id <= 0: raise ValueError("user_id must be positive or omitted") new_event = event_log.log_event(posted_data, event_type_id, user_id, node_id) return Response(json.dumps({"success": True, "event_id": new_event.event_id})) except APIKeyRateLimited: abort(420) except APIKeyInvalid: abort(404) except APIKeySuspended: abort(403)
class TestListEventTypes(unittest.TestCase): def setUp(self) -> None: # my default development environment values dev = Environment("localhost", "localhost", "pico", "password", "picoevent", "picoevent_test_db", 1000, 3600, "localhost", "localhost") self._db = Database(env=dev) self._event_log = EventLog(self._db) self._event_type_ids = self._event_log.list_event_types() def test_listUnitTypes(self): new_api_key = binascii.hexlify(os.urandom(8)).decode('utf-8').upper() result = self._db.create_api_key(new_api_key, rate_limit_quota=15000, next_reset_seconds=5000) self.assertGreater(result, 0) rest_client = PicoEventRestClient.PicoEventRestClient( TEST_ENDPOINT, new_api_key) retrieved_event_types = rest_client.get_event_types() self.assertEqual(len(retrieved_event_types), len(self._event_type_ids)) for x in range(0, len(retrieved_event_types)): event_type = self._event_type_ids[x] retrieved_event_type = retrieved_event_types[x] self.assertEqual(event_type[0], retrieved_event_type[0]) self.assertEqual(event_type[1], retrieved_event_type[1])
class TestListAPIKeys(unittest.TestCase): def setUp(self): self._db = Database(logger, True) self._target_api_keys = random.randint(5, 100) self._api_keys = [] for x in range(0, self._target_api_keys): new_api_key = binascii.hexlify( os.urandom(8)).decode('utf-8').upper() result = self._db.create_api_key(new_api_key) self.assertGreater(result, 0) self._api_keys.append(new_api_key) def test_list_api_keys(self): all_api_keys = self._db.list_api_keys() self.assertEqual(self._target_api_keys, len(all_api_keys)) for x in range(0, self._target_api_keys): self.assertEqual(all_api_keys[x][1], self._api_keys[x])
def latest_events(limit, session_token): with current_app.app_context(): environment = Environment(current_app) db = Database(logger=current_app.logger, env=environment, read_only=True) try: user = db.validate_session(session_token) # TODO: permissions event_log = EventLog(db, logger=current_app.logger) _latest_events = event_log.retrieve_events(limit=limit) json_array = [] for each_event in _latest_events: json_array.append(str(each_event)) return Response(json.dumps({"success": True, "count": len(json_array), "events": json_array})) except DatabaseException: abort(403)
def setUp(self): self._db = Database(logger, True) self._event_log = EventLog(self._db, logger) self._added_events = [] x = 0 for each_event in DEFAULT_EVENTS: event_type_id = self._event_log.add_event_type(each_event) self.assertGreater(event_type_id, 0) self._added_events.append(each_event) if x == 4: break x += 1
def setUp(self): self._db = Database(logger, True) self._mock_data = dict() now = datetime.now() for each in DEFAULT_EVENTS: event_type_id = self._db.create_event_type(each) self.assertGreater(event_type_id, 0, msg="Failed to create event type") mock_events = [] for x in range(0, random.randint(10, 50)): mock_event_data = { "floatMock": random.random(), "datetimeMock": random_later_datetime().isoformat(), "integerMock": random.randint(0, 1500000), "stringMock": "a" * random.randint(0, 1024) } new_mock_event = Event(0, event_type_id, each, mock_event_data, 0, 1, now) mock_events.append(new_mock_event) self._mock_data[each] = mock_events
class TestRateLimitQuota(unittest.TestCase): TEST_LIMIT = 500 def setUp(self): self._db = Database(logger, True) new_api_key = binascii.hexlify(os.urandom(8)).decode('utf-8').upper() node_id = self._db.create_api_key(new_api_key) self.assertGreater(node_id, 0) self.api_key = new_api_key self.node_id = node_id def test_rateLimit(self): for x in range(0, self.TEST_LIMIT): self.assertTrue(self._db.update_quota(self.node_id)) node_info = self._db.validate_api_key(self.api_key) self.assertEqual(node_info[0], self.node_id) self.assertEqual(node_info[4], self.TEST_LIMIT) next_reset = self._db.next_quota_reset self.assertTrue(self._db.reset_quota(self.node_id, next_reset)) node_info = self._db.validate_api_key(self.api_key) self.assertEqual(node_info[0], self.node_id) self.assertEqual(0, node_info[4])
def add_event_type(session_token): with current_app.app_context(): environment = Environment(current_app) db = Database(logger=current_app.logger, env=environment) user_object = db.validate_session(session_token) if user_object and user_object.has_permission("add-event-type"): new_event_type = request.form["new_event_type"] if EVENT_TYPE_REGEX.match(new_event_type): new_event_type_id = db.create_event_type(new_event_type) if new_event_type_id: return Response(json.dumps({"new_event_type_id": new_event_type_id, "success": True})) else: return Response(json.dumps({"success": False, "error_message": "Could not add to database.", "error_code": 1})) else: return Response(json.dumps({"success": False, "error_message": "Invalid event type name.", "error_code": 2})) return Response(status=403)
def login(): with current_app.app_context(): environment = Environment(current_app) input_data = request.get_json(True) username = input_data["username"] password = input_data["password"] db = Database(logger=current_app.logger, env=environment) try: result = db.login(username, password) session_token = result[0] return json.dumps({ "success": True, "session_token": session_token.decode('utf-8') }) except DatabaseException: flash("Invalid e-mail/password combination.", category="error") return json.dumps({ "success": False, "error_msg": "Invalid e-mail/password combination." })
def home(session_token): with current_app.app_context(): environment = Environment(current_app) db = Database(logger=current_app.logger, env=environment) event_log = EventLog(db, current_app.logger) user = db.validate_session(session_token) if user: event_types = event_log.list_event_types() color_schema_css = "" color_schema = DefaultColorSchema() for x in range(0, len(event_types)): rgb = color_schema.rgb(x) css = "#event_row_id_{0} {{ background-color: rgb({1},{2},{3}); }}".format( x, rgb[0], rgb[1], rgb[2]) color_schema_css += css + "\n" api_keys = event_log.list_api_keys() return render_template("admin_control_panel.jinja2", session_token=session_token, event_types=event_types, api_keys=api_keys, color_schema_css=color_schema_css) return redirect(url_for("admin_no_session"))
def add_event_type(): with current_app.app_context(): environment = Environment(current_app) session_token = request.form['token'] new_event_name = request.form['new_event_name'] db = Database(logger=current_app.logger, env=environment) user = db.validate_session(session_token) if user and user.has_permission("add-event-type"): event_log = EventLog(db, current_app.logger) try: new_event_id = event_log.add_event_type(new_event_name) if new_event_id > 0: return redirect( url_for("admin.home", session_token=session_token)) except EventLogException: current_app.logger.error( "Event log exception on add_event_type: {0}".format( new_event_name)) flash("Event log/database exception on add_event_type function.", "error") return redirect(url_for("admin.home", session_token=session_token)) flash("Not authorized.", category="error")
def list_event_types(api_key): with current_app.app_context(): environment = Environment(current_app) db = Database(logger=current_app.logger, env=environment) event_log = EventLog(db, logger=current_app.logger) try: node = event_log.get_api_key_object(api_key) event_log.update_quota(node) output = json.dumps({"success": True, "event_types": event_log.list_event_types()}) return output except APIKeyRateLimited: abort(420) except APIKeyInvalid: abort(404) except APIKeySuspended: abort(403)
def display_menu(self): if self._state == "USER_ADMIN": self._user_admin_mgr.main_menu() print("Console Administration Main Menu\n") try: test_db = Database(self._logger, True, False, self._env) del test_db except DatabaseException: print( "Warning: Test database does not exist or is not accessible with supplied credentials." ) print("\n") x = 1 for choice in ConsoleMainMenuManager.MAIN_MENU: print("{0}.) {1}".format(x, choice)) x += 1 choice = self.select_item(1, 3) if choice == 1: self.change_administrator_password() elif choice == 2: _db = Database(self._logger, False, False, self._env) # node_id, api_key, created, quota, next_reset, events_posted all_api_keys = _db.list_api_keys() del _db print( "Node ID\tAPI Key\tCreated\tQuota\tNext Reset\tEvents Posted") for each_key in all_api_keys: print("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}".format( each_key[0], each_key[1], each_key[2].isoformat(), each_key[3], each_key[4], each_key[5])) elif choice == 3: print( "Would you like to set a custom quota reset interval for the new API key?" ) custom_reset_seconds = None if self.confirm(): day_seconds = 3600 * 24 print( "Choose a quota reset interval in seconds between 1 and {0}" .format(day_seconds)) custom_reset_seconds = self.select_item(1, day_seconds) print("Would you like to set a custom quota for the new API key?") custom_quota = None if self.confirm(): print("Choose a custom quota between 100 and 50000") custom_quota = self.select_item(100, 50000) new_api_key = binascii.hexlify( os.urandom(8)).decode('utf-8').upper() _db = Database(self._logger, False, False, self._env) node_id = _db.create_api_key(new_api_key, custom_quota, custom_reset_seconds) if node_id > 0: api_key_info = _db.validate_api_key(new_api_key) print( "New API Key {0} generated with a quota of {1}, next reset {1}." .format(api_key_info[1], api_key_info[4], api_key_info[5])) else: print( "Could not create a new API key, check log file for more info." ) del _db elif choice == 4: print( "Reset quota (you will need the node id from the API key list)" ) _db = Database(self._logger, False, False, self._env) all_node_ids = set() for each_api_key in _db.list_api_keys: all_node_ids.add(each_api_key[0]) repeat = True node_id = None while repeat: user_input = int(input("Node ID: ")) if user_input in all_node_ids: node_id = user_input break print( "Node ID {0} not in the list of active API keys. Try again?" ) repeat = self.confirm() if node_id: next_reset = _db.reset_quota print( "Would you like to set a custom reset interval (default: 3600 seconds)" ) if self.confirm(): day_seconds = 3600 * 24 print( "Choose a quota reset interval in seconds between 1 and {0}" .format(day_seconds)) next_reset = datetime.now() + timedelta( seconds=self.select_item(1, day_seconds)) _db.reset_quota(node_id, next_reset) elif choice == 5: self.user_admin_mode(self._user_id, self._session_token) else: print("Bye") sys.exit(0) input("Press Enter to continue")
class EventLog: def __init__(self, db=None, logger=None): self._cache = redis.Redis() if db: self._db = db else: self._db = Database(logger) self._logger = logger event_types = [] for each in self.list_event_types(): event_types.append(each[1]) missing_events = set(DEFAULT_EVENTS) - set(event_types) for new_event in missing_events: self._db.create_event_type(new_event) def deserialize_user_object(self, event: Event): if event.is_analyst(): cached_user_data = self._cache.get("analyst:{0}".format( event.user_id)) if cached_user_data: user_data = json.dumps(cached_user_data) new_analyst_user = AnalystUser( user_data["user_id"], user_data["email_address"], user_data["session_token"], user_data["full_name"], user_data["permissions"], user_data["view_event_type_ids"]) return new_analyst_user else: cached_user_data = self._cache.get("django:{0}".format( event.user_id)) if cached_user_data: user_data = json.dumps(cached_user_data) new_django_user = DjangoUser( user_data["user_id"], user_data["username"], user_data["first_name"], user_data["last_name"], user_data["email_address"], datetime.datetime.strptime(user_data["created"], "%Y-%m-%dT%H:%M:%S%z"), datetime.datetime.strptime(user_data["last_logged_in"], "%Y-%m-%dT%H:%M:%S%z")) return new_django_user def get_api_key_object(self, api_key: str) -> APIKey: try: node_data = self._db.validate_api_key(api_key) node = APIKey(node_data[0], api_key, node_data[1], node_data[2], node_data[3], node_data[4], node_data[5]) if node.suspended_event: raise APIKeySuspended if node.next_reset is None or node.next_reset < datetime.datetime.now( ): next_reset = datetime.datetime.now() + datetime.timedelta( hours=1) node.next_reset = next_reset node.events_posted = 0 self._db.reset_quota(node.node_id, next_reset) if node.events_posted >= node.quota: raise APIKeyRateLimited return node except DatabaseException: raise APIKeyInvalid def list_api_keys(self) -> list: output = [] try: all_api_keys = self._db.list_api_keys() except DatabaseException: raise EventLogException for each_api_key in all_api_keys: new_api_key = APIKey(each_api_key[0], each_api_key[1], each_api_key[2], each_api_key[3], each_api_key[4], each_api_key[5], each_api_key[6]) output.append(new_api_key) return output def add_event_type(self, new_event_type): self._cache.delete("event_types") new_event_type_id = self._db.create_event_type(new_event_type) if new_event_type_id > 0: return new_event_type_id raise EventLogException @property def event_type_ids_as_set(self) -> set: try: all_event_types = self.list_event_types() all_event_type_ids = [] for each in all_event_types: all_event_type_ids.append(each[0]) return set(all_event_type_ids) except EventLogException: raise EventLogException def list_event_types(self) -> list: event_types_cached = self._cache.get("event_types") if event_types_cached: event_types = json.loads(event_types_cached) else: event_types = self._db.list_event_types() self._cache.set("event_types", json.dumps(event_types)) if len(event_types) == 1 and event_types[0][0] == -1: raise EventLogException return event_types def get_event_count(self, user_id=None, event_type_id=None, since=None, until=None): return self._db.get_event_count(user_id, event_type_id, since, until) def log_event(self, event_data: dict, event_type_id: int, user_id: int = None, node_id: int = None): event_id = self._db.log_event(event_data, event_type_id, user_id, node_id) if event_id: event_type = None for event in self.list_event_types(): if event[0] == event_type_id: event_type = event[1] break if not event_type: raise EventLogException new_event = Event(event_id, event_type_id, event_type, event_data, user_id, node_id, datetime.datetime.now().isoformat()) self._cache.set("event_id:{0}".format(event_id), str(new_event)) return new_event raise EventLogException def get_event(self, event_id: int) -> Event: cached_event_data = self._cache.get("event_id:{0}".format(event_id)) new_event = None if cached_event_data: cached_obj = json.loads(cached_event_data) new_event = Event( cached_obj["event_id"], cached_obj["event_type_id"], cached_obj["event_type"], cached_obj["event_data"], cached_obj["node_id"], cached_obj["user_id"], datetime.datetime.strptime(cached_obj["created"], "%Y-%m-%dT%H:%M:%S%z")) else: db_event_record = self._db.get_event_data(event_id) if db_event_record: # event_id, event_type_id, node_id, user_id, event_data, created, event_type.event_type new_event = Event(db_event_record[0], db_event_record[1], db_event_record[2], json.loads(db_event_record[4]), db_event_record[2], db_event_record[3], db_event_record[5]) if new_event: return new_event else: raise EventLogException def retrieve_events(self, user_id: int = None, since: datetime = None, until: datetime = None, event_type_id: int = None, node_id: int = None, limit: int = 100): try: meta_data = self._db.retrieve_events(user_id, event_type_id, node_id, since, until, limit) # event_id, event_type_id, node_id, user_id, created output = [] for row in meta_data: event_id = row[0] cache_key = "event_id:{0}".format(event_id) event_data = self._cache.get(cache_key) if event_data is None: event_data = self._db.get_event_data(event_id) new_event = Event(event_data[0], event_data[1], event_data[6], json.loads(event_data[4]), event_data[3], event_data[2], event_data[5]) self._cache.set(cache_key, str(new_event)) output.append(json.loads(str(new_event))) else: output.append(json.loads(event_data)) return output except DatabaseException: raise EventLogException def update_quota(self, node: APIKey): try: self._db.update_quota(node.node_id) except DatabaseException: if self._logger: self._logger.error( "Failed to update API rate quota for node id: {0}".format( node.node_id))
def setUp(self): self._db = Database(logger, True)
class TestEventTypeIdLogging(unittest.TestCase): def setUp(self): self._db = Database(logger, True) self._mock_data = dict() now = datetime.now() for each in DEFAULT_EVENTS: event_type_id = self._db.create_event_type(each) self.assertGreater(event_type_id, 0, msg="Failed to create event type") mock_events = [] for x in range(0, random.randint(10, 50)): mock_event_data = { "floatMock": random.random(), "datetimeMock": random_later_datetime().isoformat(), "integerMock": random.randint(0, 1500000), "stringMock": "a" * random.randint(0, 1024) } new_mock_event = Event(0, event_type_id, each, mock_event_data, 0, 1, now) mock_events.append(new_mock_event) self._mock_data[each] = mock_events def test_logging(self): total_events_logged = 0 event_type = random.choice(DEFAULT_EVENTS) mock_events = self._mock_data[event_type] event_type_id = None for each_mock in mock_events: if event_type_id is None: event_type_id = each_mock.event_type_id event_id = self._db.log_event(each_mock.event_data, each_mock.event_type_id, each_mock.node_id, each_mock.user_id) self.assertGreater(event_id, 0, msg="Failed to log event.") each_mock.event_id = event_id event_type_count = self._db.get_event_count( event_type_id=event_type_id) self.assertEqual(event_type_count, len(mock_events)) logger.info("Events logged: {0} ({1})".format(event_type_count, event_type)) logger.info("Fetching events individually...") total_events_logged += event_type_count for each_mock in mock_events: db_event_data = self._db.get_event_data(each_mock.event_id) # DB: event_id, event_type_id, node_id, user_id, event_data, created, event_type.event_type self.assertEqual(db_event_data[1], each_mock.event_type_id) self.assertEqual(db_event_data[2], each_mock.node_id) self.assertEqual(db_event_data[3], each_mock.user_id) # db_event_data = json.loads(db_event_data[4]) # self.assertEqual(each_mock.event_data["floatMock"], db_event_data["floatMock"]) # self.assertEqual(db_event_data[6], each_event_type) logger.info("Retrieving all events of type in single query...") all_events_of_type = self._db.retrieve_events( event_type_id=event_type_id) mock_events_reversed = mock_events mock_events_reversed.reverse() # event_id, event_type_id, node_id, user_id, created for x in range(0, len(mock_events_reversed)): self.assertEqual(all_events_of_type[x][0], mock_events_reversed[x].event_id) self.assertEqual(all_events_of_type[x][1], mock_events_reversed[x].event_type_id) self.assertEqual(all_events_of_type[x][2], mock_events_reversed[x].node_id) self.assertEqual(all_events_of_type[x][3], mock_events_reversed[x].user_id) self.assertEqual(len(all_events_of_type), event_type_count) db_total_event_count = self._db.get_event_count() self.assertEqual(db_total_event_count, total_events_logged)
def __init__(self, environment, user_id, session_token, use_logger=None): self._db = Database(env=environment, logger=use_logger) self._session_token = session_token self._user_id = user_id
class ConsoleUserManager(ConsoleMenu): MAIN_MENU_CHOICES = [ "List Users", "Create User", "List Permissions for User", "Assign User Permission", "Revoke User Permission", "List Event Types", "Reset Password", "Back to Main Menu" ] def __init__(self, environment, user_id, session_token, use_logger=None): self._db = Database(env=environment, logger=use_logger) self._session_token = session_token self._user_id = user_id def main_menu(self): print("User Administration Menu\n") x = 1 choices = ConsoleUserManager.MAIN_MENU_CHOICES for each in choices: print("{0}.) ".format(x) + each) x += 1 choice = self.select_item(1, len(choices) + 1) if choice == 1: self.list_users() elif choice == 2: self.create_user() elif choice == 3: query_user_id = int(input("List permissions for user_id: ")) self.list_permissions_for_user_id(query_user_id) elif choice == 4: query_user_id = int( input("Assign view-event-id permission for user_id: ")) query_event_type_id = int(input("Event type id: ")) self.assign_permission_for_user_id(query_user_id, "view", query_event_type_id) elif choice == 5: print("Not yet implemented.") elif choice == 6: event_types = db.list_event_types() print("ID\tEvent Type") for each_event in event_types: print("{0}\t{1}".format(each_event[0], each_event[1])) elif choice == 7: username = input("Reset password for user with email/username: "******"New password: "******"\nPress Enter to continue") self.main_menu() def reset_password(self, email, new_passwd): try: self._db.reset_password(email, new_passwd) print("Password successfully changed.") except DatabaseException: print("Database Exception: Could not change password.") def list_users(self): try: user_list = self._db.list_analyst_user_info() # user_id, email_address, full_name, last_logged_in print("User ID\tLogin/E-mail\tFull Name\tLast Logged In\n\n") for each_user in user_list: print("{0}\t{1}\t{2}\t{3}".format(each_user[0], each_user[1], each_user[2], each_user[3])) print("\n\n") except DatabaseException: print("Database error.") def create_user(self, email=None, passwd=None, name=None): if email is None: email = input("E-mail address: ") if passwd is None: passwd = input("Password: "******"Name: ") try: new_user = self._db.create_user(email, passwd, name, "console") print("Created new user with ID: {0}".format(new_user[0])) except DatabaseException: print("Could not create a new user.") def list_permissions_for_user_id(self, uid): try: user_permissions = self._db.list_permissions_for_user_id(uid) print("ACL ID\tPermission\tEvent Type ID\tCreated\tRevoked\n") for each_permission in user_permissions: print("{0}\t{1}\t{2}\t{3}\t{4}".format(each_permission[0], each_permission[2], each_permission[1], each_permission[6], "NO")) except DatabaseException: print("Could not create a new user.") def assign_permission_for_user_id(self, uid, permission, event_type_id=None): if permission is "view-event-type" and event_type_id: event_type = None all_event_types = self._db.list_event_types() for each_event_type in all_event_types: if each_event_type[0] == event_type_id: event_type = each_event_type[1] break if event_type: logged_event_type_id = None for each_event_type in all_event_types: if each_event_type[1] is "Add Permission": logged_event_type_id = each_event_type[0] break try: event_id = self._db.log_event( { "assigned_by": "Administrator", "ip_addr": "console", "event_type": event_type, "event_type_id": event_type_id }, logged_event_type_id, 0, uid) new_acl_id = self._db.assign_permission_for_user_id( uid, permission, event_id, event_type_id) print("Assigned new permission ID {0} to user_id {1}.". format(new_acl_id, uid)) except DatabaseException: print("Could not assign a new permission.") def revoke_permission_for_user_id(self, uid, permission_id): pass
print( "Could not open the PicoEvent/config/config.json file for reading. Exiting." ) sys.exit() logger = None if "console_logging_enabled" in config and config[ "console_logging_enabled"]: if "console_log_file" in config: print("Logging to file: {0}".format(config["console_log_file"])) logger = setup_file_logging(config["console_log_file"]) env = ConsoleEnvironment() context_manager = ConsoleMainMenuManager(env, logger) db = Database(env=env, logger=logger) session_id = None admin_user_id = -1 def login_admin(): attempts = 0 while attempts < MAX_LOGIN_ATTEMPTS: password = input("admin password: "******"admin", password) return login_info[0] except DatabaseException: attempts += 1 print( "Login failed, try again. ({0} attempts remaining)".format( MAX_LOGIN_ATTEMPTS - attempts))