def init_nodes(self): logManager.info('Initialize nodes') all_nodes = self.node.query.all() for n in all_nodes: if n.authorized is True: self.activate_node(n) self.db.session.commit()
def handle(self, action, user, workspace, actionManager): # userManager = actionManager.userManager menuBuilder = actionManager.menuBuilder logManager.info("Execute registration action") menu = menuBuilder.buildMenu(user) updateMenu_action = webclientActions.UpdateMenuAction.generate(menu) return 'success', [updateMenu_action]
def discoverNodeClasses(self, workspaceSource): # for _, node_class, ispkg in pkgutil.iter_modules(imported_source.__path__, imported_source.__name__ + '.'): # if ispkg: # print(node_class) node_sources = workspaceSource + '.' + self.name + '.' + 'nodes' imported_source = __import__(node_sources, fromlist=['blah']) for _, nodename, ispkg in pkgutil.iter_modules( imported_source.__path__, imported_source.__name__ + '.'): if not ispkg: node_module = __import__(nodename, fromlist=['blah']) clsmembers = inspect.getmembers(node_module, inspect.isclass) for (_, c) in clsmembers: # Check for DataView classes if issubclass(c, NodeClass) & (c is not NodeClass): if c.disable is False: logManager.info( f'NodeClass: "{c.__module__}" loaded from "{node_sources}"' ) nodeManager.register_node_class(self, c) else: logManager.info( f'NodeClass: "{c.__module__}" is diabled and wont show up"' ) '''
def handle(self, action, user, workspace, actionManager): logManager.info("Execute lost password action") notification_action = webclientActions.NotificationAction.generate( "A email to reset the password will be send to you", "success") ref = request.referrer.split('/') if ref[0] != 'http:' and ref[0] != 'https:': ref = '/'.join(ref[:1]) else: ref = '/'.join(ref[:3]) resetUser = userManager.getUser(action.username) if resetUser is not None: key = ''.join( random.choices(string.ascii_letters + string.digits, k=96)) resetUser.password_reset_expired_date = arrow.utcnow().shift( hours=2) resetUser.password_reset_hash = key link = ref + '/user/resetpassword' + '?key=' + key data = { 'username': resetUser.firstname + ' ' + resetUser.lastname, 'reset_link': link } print(key) send_mail([resetUser.email], "Reset your password", workspace, 'lostPassword.mail', data) return 'success', [notification_action]
def discoverModels(self): source = self.workspaceSource imported_source = __import__(source, fromlist=['blah']) all_current_paths = [] # all_current_paths.append(imported_source.__path__._path) if isinstance(imported_source.__path__, str): all_current_paths.append(imported_source.__path__) else: all_current_paths.extend([x for x in imported_source.__path__]) # remove duplicates all_current_paths = list(set(all_current_paths)) for pkg_path in all_current_paths: # Walk through all sub directories child_pkgs = [ p for p in os.listdir(pkg_path) if os.path.isdir(os.path.join(pkg_path, p)) ] for child_pkg in child_pkgs: try: __import__(source + '.' + child_pkg + '.models', fromlist=['blah']) except ModuleNotFoundError: modelmodule = source + '.' + child_pkg + '.models' logManager.info(f'No model found for {modelmodule}') print(child_pkg) print("Finished")
def handle(self, action, user, workspace, actionManager): logManager.info("Execute registration action") replyActions = [] userdata = action['userdata'] if userManager.checkUserExist(userdata['email']): replyActions.append( webclientActions.NotificationAction.generate( "User already exist", "error")) else: u = userManager.registerUser(userdata) link = generateActionLink(workspace, 'verifyUser', {'email': userdata['email']}, "user/login", True, False) data = { 'username': userdata['firstname'] + ' ' + userdata['lastname'], 'action_link': link } send_mail([userdata['email']], "#Rosenwerk Account verifizieren", workspace, 'requestVerification.mail', data) send_message(u, "Welcome", workspace, 'welcome.message', data, 'Roseguarden', False, 'welcome.mail') replyActions.append( webclientActions.NotificationAction.generate( "User registered", "success")) replyActions.append( webclientActions.RouteAction.generate("dashboard", 3)) return 'success', replyActions
def handle(self, action, user, workspace, actionManager): logManager.info("Execute get view action for", action['view']) viewname = action['view'] print(workspace.dataViews) if viewname in workspace.dataViews: print('found view', viewname, 'in', workspace.name, workspace.dataViews[viewname]) view = workspace.dataViews[viewname] # check if login required for this view if view.requireLogin is True and user is None: raise RequireLoginError else: # build actions to get view meta_data = view.getViewMetaHandler(user, workspace) entries = view.getViewHandler(user, workspace, None) properties = view.getProperties() uri = workspace.uri + '/' + view.uri loadviewaction = webclientActions.LoadViewAction.generate( uri, properties, entries, meta_data) return 'success', [loadviewaction] # view not found notification_action = webclientActions.NotificationAction.generate( "View >" + viewname + "< not found", "error") return 'success', [notification_action]
def handle(self, action, user, workspace, actionManager): logManager.info("Execute action '{}' on view '{}'", action['viewAction'], action['view']) viewname = action['view'] if viewname in workspace.dataViews: print('found view', viewname, 'in', workspace.name, workspace.dataViews[viewname]) view = workspace.dataViews[viewname] # check if login required for this view if view.requireLogin is True and user is None: raise RequireLoginError else: # build actions to get view response_actions = [] response_data = None try: view.dataSyncs = [] dictionary = action response_data = view.executeViewActionHandler( user, workspace, ObjDict(dictionary)) notification_action = webclientActions.NotificationAction.generate( "Action '" + str(action['viewAction']) + "' executed", "info") response_actions.append(notification_action) self.db.session.commit() for v in view.dataSyncs: updateView = workspace.dataViews[v['view']] meta_data = updateView.getViewMetaHandler( user, workspace) entries = updateView.getViewHandler( user, workspace, None) properties = updateView.getProperties() uri = workspace.uri + '/' + updateView.uri loadviewaction = webclientActions.LoadViewAction.generate( uri, properties, entries, meta_data) response_actions.append(loadviewaction) except Exception as e: notification_action = webclientActions.NotificationAction.generate( "Action '" + str(action['viewAction']) + "' failed with: ", "error") response_actions = [notification_action] logManager.error( str(type(e).__name__) + 'in ExecuteViewActionsActionHandler', action['view']) traceback.print_exc(file=sys.stdout) # entries = view.getViewHandler(user, workspace) # properties = view.getProperties() # uri = view.uri # loadviewaction = webclientActions.LoadViewAction.generate(uri, properties, entries) if response_data is not None: return 'success', response_actions, response_data else: return 'success', response_actions # view not found notification_action = webclientActions.NotificationAction.generate( "View >" + viewname + "< not found", "error") return 'success', [notification_action]
def mapWorkspaces(self, app): logManager.info("") logManager.info("ActionManager map workspaces") self.workspacesMap = {} for w in self.workspaceManager.workspaces: self.workspacesMap[str(w.uri)] = w pprint(self.workspacesMap, indent=2)
def addDateArgument(self, name, label="", description="", optional=False, group=None): logManager.info("Add date tyme argument for job {}".format(self.name)) self.addArgument(name, 'date', label, description, optional, group)
def addDoubleArgument(self, name, label="", description="", optional=False, group=None): logManager.info("Add double type argument to job {}".format(self.name)) self.addArgument(name, 'double', label, description, optional, group)
def addStringArgument(self, name, label="", description="", optional=False, group=None): logManager.info("Add string type argument to job {}".format(self.name)) self.addArgument(name, 'string', label, description, optional, group)
def handle(self, action, user, workspace, actionManager): logManager.info("Request user verification") user = User.query.filter_by(email=action.email).first() if user is None: raise Exception("User not found") else: user.account_verified = True return 'success', []
def trigger_job(job_key, args, user): logManager.info("User {} triggered job {}".format(user.email, job_key)) job_id = jobManager.run_job(user, job_key, args, datetime.now() + timedelta(seconds=5), log_trigger=True) return job_id
def handle(self, action, user, workspace, actionManager): logManager.info("Execute login action") replyActions = [] user = (actionManager.userManager.getUser(action['username'])) if user is not None: if user.account_verified is False: replyActions.append( webclientActions.NotificationAction.generate( "Your account need to be verified before login.", "warning")) return 'success', replyActions if user.checkPassword(action['password']): userManager = actionManager.userManager menuBuilder = actionManager.menuBuilder # update serverside jwt token access_token = userManager.updateAccessToken( action['username']) # update menu menu = menuBuilder.buildMenu(user) # build up replyActions.append( webclientActions.UpdateSessionTokenAction.generate( access_token)) replyActions.append( webclientActions.UpdateMenuAction.generate(menu)) replyActions.append( webclientActions.NotificationAction.generate( "Login successful.", "success")) if 'options' in action and 'redirect' in action['options']: if action['options']['redirect'] != "": replyActions.append( webclientActions.RouteAction.generate( action['options']['redirect'], 2)) else: replyActions.append( webclientActions.RouteAction.generate( "dashboard", 2)) replyActions.append( webclientActions.UpdateUserInfoAction.generate( user.firstname, user.lastname, user.email)) user.sessionValid = True user.last_login_date = arrow.utcnow() # actionManager.db.session.commit() else: replyActions.append( webclientActions.NotificationAction.generate( "Login failed, username or password is wrong.", "error")) else: replyActions.append( webclientActions.NotificationAction.generate( "Login failed, username or password is wrong.", "error")) return 'success', replyActions
def addIntegerArgument(self, name, label="", description="", optional=False, group=None): logManager.info("Add integer type argument for job {}".format( self.name)) self.addArgument(name, 'integer', label, description, optional, group)
def addBooleanArgument(self, name, label="", description="", optional=False, group=None): logManager.info("Add boolean type argument for job {}".format( self.name)) self.addArgument(name, 'boolean', label, description, optional, group)
def init_manager(self, app, db, workspaceManager): self.app = app self.db = db self.workspaceManager = workspaceManager logManager.info("NodeManager initialized") from core.nodes.models import Node, NodeLog self.node = Node self.nodeLog = NodeLog
def handle(self, action, user, workspace, actionManager): logManager.info("Execute update of view entry for '{}'", action['view']) viewname = action['view'] if viewname in workspace.dataViews: view = workspace.dataViews[viewname] # check if login required for this view if view.requireLogin is True and user is None: raise RequireLoginError else: # build actions to get view responseActions = [] try: if view.entrykey not in action['entry']: notification_action = webclientActions.NotificationAction.generate( "UpdateViewEntryActionHandler miss entrykey", "error") responseActions = [notification_action] else: view.dataSyncs = [] dictionary = action['entry'] view.updateViewEntryHandler( user, workspace, action['entry'][str(view.entrykey)], ObjDict(dictionary)) self.db.session.commit() for v in view.dataSyncs: updateView = workspace.dataViews[v['view']] entries = updateView.getViewHandler( user, workspace, None) meta_data = updateView.getViewMetaHandler( user, workspace) properties = updateView.getProperties() uri = workspace.uri + '/' + updateView.uri loadviewaction = webclientActions.LoadViewAction.generate( uri, properties, entries, meta_data) responseActions.append(loadviewaction) responseActions.append( webclientActions.NotificationAction.generate( "Updated successfully", "success")) return 'success', responseActions except Exception as e: notification_action = webclientActions.NotificationAction.generate( "UpdateViewEntry '" + str(action['view']) + "' failed with: " + str(e), "error") responseActions = [notification_action] logManager.error( str(type(e).__name__) + 'in ExecuteViewActionsActionHandler ' + action['view']) traceback.print_exc(file=sys.stdout) return 'success', responseActions notification_action = webclientActions.NotificationAction.generate( "View >" + viewname + "< not found", "error") return 'success', [notification_action]
def reloadWorkspaces(self): """Reset the list of all plugins and initiate the walk over the main provided plugin package to load all available plugins """ self.workspaces = [] self.seen_paths = [] logManager.info("") logManager.info( f'Discover workspaces in path : {self.workspaceSource}') self.discoverWorkspaces(self.workspaceSource)
def init_app(self, app, db): self.app = app self.db = db with self.app.app_context(): self.reloadWorkspaces() self.registerWorkspacePlugins() self.registerWorkspacePermissions() logManager.info("Workspaces initialized") self.register_command_line_client() logManager.info("Command line client initialized")
def handle(self, action, user, workspace, actionManager): logManager.info("Trigger job") response_actions = [] job_execution_id = trigger_job(action.jobId, {}, user) notification_action = webclientActions.NotificationAction.generate( "Action triggered", "info") response_actions.append(notification_action) return 'success', response_actions, { "job_execution_id": job_execution_id }
def discoverCommands(self, workspaceSource): command_source_path = workspaceSource + '.' + self.name + '.' + 'commands' # print("Discover actions for", self.uri, "from", actionsSource) try: command_source = __import__(command_source_path, fromlist=['blah']) self.app.register_blueprint(command_source.bp, cli_group=self.uri) except ModuleNotFoundError: logManager.info( f'No commands found for for workspace "{self.name}"')
def handle(self, action, user, workspace, actionManager): user_to_assign = User.query.filter_by(email=action.userId).first() authenticator = Authenticator.query.filter_by( code=action.authenticatorCode).first() notification_action = webclientActions.NotificationAction.generate( "Assign authenticator was succesful.", "success") if user is None: notification_action = webclientActions.NotificationAction.generate( "You need to be logged in to do this action.", "error") return 'success', [notification_action], { 'succeed': False, 'message': "You have to be logged in to do this action." } logManager.info("Request for authenticator assign for {} by {}".format( action.userId, user.email)) if user_to_assign is None: notification_action = webclientActions.NotificationAction.generate( "Failed to assign authenticator to user.", "error") return 'success', [notification_action], { 'succeed': False, 'message': "Failed to assign authenticator to user." } # there is no authenticator for the given authenticator code if authenticator is None or action.authenticatorCode == '' or action.authenticatorCode is None: notification_action = webclientActions.NotificationAction.generate( "Failed to assign authenticator to user.", "error") return 'success', [notification_action], { 'succeed': False, 'message': "Failed to assign authenticator to user." } # other user can only set authenticator if not already set if user.email != user_to_assign.email: if user_to_assign.authenticator_status is not UserAuthenticatorStatus.UNSET: notification_action = webclientActions.NotificationAction.generate( "Failed to assign authenticator to user", "error") return 'success', [notification_action], { 'succeed': False, 'message': "Failed to assign authenticator to user." } user_to_assign.setAuthenticatorHash(authenticator.authenticator) user_to_assign.authenticator_public_key = authenticator.authenticator_public_key user_to_assign.authenticator_status = UserAuthenticatorStatus.VALID return 'success', [notification_action], { 'succeed': True, 'message': "Assign successful" }
def init_manager(self, app, db, workspaceManager, config): self.config = config self.app = app self.db = db self.workspaceManager = workspaceManager from core.messages.models import Message self.message = Message jobManager.register_job(None, MailFromFileTemplateJob) logManager.info("MessageManager initialized")
def init_manager(self, app, db, workspaceManager, config): self.config = config self.app = app self.db = db self.workspaceManager = workspaceManager self.pinAttemptLimit = 6 logManager.info("UserManager initialized") from core.users.models import User, Authenticator self.user = User self.authenticator_request = Authenticator self.user_authenticator_cache = {}
def mapActions(self, app): logManager.info("") logManager.info("ActionManager map actions") # register workspaces for w in self.workspaceManager.workspaces: self.actionsMap[str(w.uri)] = {} # map actions for every workspace by there uri for a in w.actions: self.actionsMap[str(w.uri)][a.uri] = a pprint(self.actionsMap, indent=2)
def listener(self, event): if type(event) is SchedulerEvent: logManager.info("Got SchedulerEvent: {}".format(str(event))) elif type(event) is JobEvent: # logManager.info("Got JobEvent: {}".format(str(event))) pass elif type(event) is JobExecutionEvent: if event.exception: logManager.info("Got JobExecutionEvent: {}".format(str(event))) elif type(event) is JobSubmissionEvent: # logManager.info("Got JobSubmissionEvent: {}".format(str(event))) pass else: logManager.warning("Unknown JobEvent")
def discoverJobs(self, workspaceSource): jobSource = workspaceSource + '.' + self.name + '.' + 'jobs' imported_source = __import__(jobSource, fromlist=['blah']) for _, jobname, ispkg in pkgutil.iter_modules( imported_source.__path__, imported_source.__name__ + '.'): if not ispkg: job_module = __import__(jobname, fromlist=['blah']) clsmembers = inspect.getmembers(job_module, inspect.isclass) for (_, c) in clsmembers: # Check for DataView classes if issubclass(c, Job) & (c is not Job): if c.disable is False: logManager.info( f'Job registered from "{c.__module__}"') jobManager.register_job(self, c, True)
def handle(self, action, user, workspace, actionManager): logManager.info("Execute change password action") if user is not None: if user.checkPassword(action['oldpassword']): user.password = action['newpassword'] notification_action = webclientActions.NotificationAction.generate( "Password changed", "success") else: notification_action = webclientActions.NotificationAction.generate( "Wrong current password!", "error") else: notification_action = webclientActions.NotificationAction.generate( "Internal error (user not found)", "error") return 'success', [notification_action]