Exemple #1
0
    def __init__(self, config):
        self.server = config.get_server()
        self.tornado_server = None
        self.api_cache = {}
        self.registered_base_handlers = []
        self.max_upload_size = config.getint('max_upload_size', 200)
        self.max_upload_size *= 1024 * 1024

        # Set Up Websocket and Authorization Managers
        self.wsm = WebsocketManager(self.server)
        self.auth = Authorization(config['authorization'])

        mimetypes.add_type('text/plain', '.log')
        mimetypes.add_type('text/plain', '.gcode')
        mimetypes.add_type('text/plain', '.cfg')
        debug = config.getboolean('enable_debug_logging', True)

        # Set up HTTP only requests
        self.mutable_router = MutableRouter(self)
        app_handlers = [(AnyMatches(), self.mutable_router),
                        (r"/websocket", WebSocket),
                        (r"/api/version", EmulateOctoprintHandler)]

        self.app = tornado.web.Application(app_handlers,
                                           serve_traceback=debug,
                                           websocket_ping_interval=10,
                                           websocket_ping_timeout=30,
                                           parent=self)
        self.get_handler_delegate = self.app.get_handler_delegate

        # Register handlers
        logfile = config['cmd_args'].get('logfile')
        self.register_static_file_handler("moonraker.log", logfile)
        self.auth.register_handlers(self)
Exemple #2
0
 def refresh_token(cls, content):
     token = content.get('token', None)
     result, msg = Authorization.verify_refresh_token(token)
     if result:
         user = UserProcess.user_map.get(msg, None)
         if user:
             token = Authorization.generate_access_token(user.user_id)
             return {'access_token': token}
     return None
Exemple #3
0
 def wrapper(*args: Any, **kwargs: Any) -> Any:
     username = get_session_username(str(request.cookies.get(SESSION_ID)))
     authorization = Authorization(calendar_data=CalendarData(data_folder=config.DATA_FOLTER))
     if "calendar_id" not in kwargs:
         raise ValueError("calendar_id")
     calendar_id = str(kwargs["calendar_id"])
     if not authorization.can_access(username=username, calendar_id=calendar_id):
         abort(403)
     return decorated_function(*args, **kwargs)
Exemple #4
0
        def add_authorization():
            get_json = json.loads(request)
            required = ['inputs', 'outputs', 'duration', 'timestamp']
            if not all(k in get_json for k in required):
                return 'Missing values', 400

            # Create a new Transaction
            authorization = Authorization(get_json['inputs'], get_json['outputs'],
                                          get_json['duration'], get_json['timestamp'])
            node.add_authorization(authorization)
            response = authorization.to_json()
            return jsonify(response), 201
class ProxyAuthorization(Header):
    def __init__(self, params=None):
        Header.__init__(self, params)
        self.name = "Proxy-Authorization"
        self.auth = Authorization()
        self.value = self.generate_valid_value()

    def generate_valid_value(self):
        return self.auth.generate_valid_value()

    def mutate_validity(self, value):
        return self.auth.mutate_validity(value)

    def mutate_length(self, value):
        return self.auth.mutate_length(value)
Exemple #6
0
    def login(cls, content):
        account_name = content.get('account_name', None)
        password = content.get('password', None)

        user = UserProcess.user_map.get(account_name, None)
        if not user or user.password != password:
            return {'message': '账户或密码不正确!'}

        return {
            'message': 'success',
            'super': '1' if account_name == 'ias_admin' else '0',
            'access_token': Authorization.generate_access_token(user.user_id),
            'refresh_token':
            Authorization.generate_refresh_token(user.user_name)
        }
Exemple #7
0
 def testGoodData(self):  # корректные логин и пароль
     test_name = "TestUser"
     test_pass = "******"
     test_code = 0
     real_code = Authorization.login(test_name, test_pass)
     res = real_code > test_code
     self.assertTrue(res)
Exemple #8
0
def log():
    if current_user.is_authenticated:
        return redirect(url_for('main_page'))
    form = LogForm()
    if form.validate_on_submit():
        user = None
        try:
            user = User.get(User.login == form.login.data)
        except User.DoesNotExist:
            pass
        auth = Authorization()
        if user is None or not auth.check_password(user, form.password.data):
            return redirect(url_for('log'))
        login_user(user)
        return redirect(url_for('main_page'))
    return render_template('log.html', form=form)
Exemple #9
0
 def testGoodData(self): # корректные логин и пароль
         test_name = "TestUser"
         test_pass = "******"
         test_code = 0
         real_code = Authorization.login(test_name, test_pass)
         res = real_code > test_code
         self.assertTrue(res)
Exemple #10
0
    def __init__(self, config):
        self.server = config.get_server()
        self.tornado_server = None
        self.api_cache = {}
        self.registered_base_handlers = []
        self.max_upload_size = config.getint('max_upload_size', 1024)
        self.max_upload_size *= 1024 * 1024

        # Set Up Websocket and Authorization Managers
        self.wsm = WebsocketManager(self.server)
        self.auth = Authorization(config['authorization'])

        mimetypes.add_type('text/plain', '.log')
        mimetypes.add_type('text/plain', '.gcode')
        mimetypes.add_type('text/plain', '.cfg')
        debug = config.getboolean('enable_debug_logging', False)
        log_level = logging.DEBUG if debug else logging.INFO
        logging.getLogger().setLevel(log_level)
        app_args = {
            'serve_traceback': debug,
            'websocket_ping_interval': 10,
            'websocket_ping_timeout': 30,
            'parent': self,
            'default_handler_class': AuthorizedErrorHandler,
            'default_handler_args': {}
        }
        if not debug:
            app_args['log_function'] = self.log_release_mode

        # Set up HTTP only requests
        self.mutable_router = MutableRouter(self)
        app_handlers = [(AnyMatches(), self.mutable_router),
                        (r"/websocket", WebSocket)]
        self.app = tornado.web.Application(app_handlers, **app_args)
        self.get_handler_delegate = self.app.get_handler_delegate

        # Register handlers
        logfile = config['system_args'].get('logfile')
        if logfile:
            self.register_static_file_handler("moonraker.log",
                                              logfile,
                                              force=True)
        self.register_static_file_handler("klippy.log",
                                          DEFAULT_KLIPPY_LOG_PATH,
                                          force=True)
        self.auth.register_handlers(self)
Exemple #11
0
def handle_dialog(req, res):
    user_id = req['session']['user_id']
    session_id = req['session']['session_id']

    if req['session']['new']:
        # Это новый пользователь.
        # Инициализируем сессию и поприветствуем его.

        sessionStorage[user_id] = {
            'suggests': [
                "Собрать тариф",
                "Пополнить счет",
                "Все что вы хотите!",
            ],
            'current_flow': None
        }

        with open(session_path + session_id + '.pickle', 'wb') as f:
            pickle.dump(sessionStorage, f)
            f.close()
        auth = Authorization(session_id)
        auth.authorize(req['request'], res)

        return

    if "расскажи" in req['request']['nlu']['tokens']:
        res['response']['text'] = 'Я - новый умный помощник от команды "3 фронтендера и я". ' \
                                  'Пока что я могу выполнять такие функции:'
        res['response']['buttons'] = [
            {
                "title": "Собрать тариф"
            },
            {
                "title": "Пополнить счет"
            },
            {
                "title": "Найти музыку"
            },
        ]

        return

    # Обрабатываем ответ пользователя.
    auth = Authorization(session_id)
    if not auth.is_authorized():
        auth.authorize(req['request'], res)
        return
    handler = GlobalHandler(session_id)
    handler.handle_request(req['request'], res)
Exemple #12
0
def main():
    print('initializing role based resource access system')

    dao = DataAccessObject()
    dao.load_data()

    authorization = Authorization(dao)

    ui = UserInterface(authorization)
    ui.start()
Exemple #13
0
def admin_authorization():
    cookies = request.cookies
    print(cookies)

    if request.method == "POST":
        username = request.form['username']
        password = request.form['password']
        admin = Authorization(username, password)

        if admin.check_log_pass_registration():
            category_list = dbmanager.get_category_name()
            print(category_list)
            resp = make_response(redirect('/admin/db_access/'))
            resp.set_cookie('secret_key', dbmanager.secret_key)
            return resp
        else:
            return render_template('admin.html',
                                   error="Wrong data. Try again!")
    else:
        return render_template('admin.html')
Exemple #14
0
class GlobalWindow(QtGui.QWidget):
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        self.setGeometry(400, 200, 400, 600)
        self.setWindowTitle('VkClient')
        self.setWhatsThis(QtCore.QString('hello'))
        self.setStyleSheet('background: #356AA0;')
        self.setFont(QtGui.QFont('Arial'))
        self.setMaximumSize(400, 600)
        self.setMinimumSize(400, 600)
        self.layout = QtGui.QVBoxLayout()
        self.top_frame = TopFrame()
        self.top_frame.show()
        self.user_frame = UserFrame()
        self.authorization = Authorization(self.user_frame)
        self.authorization.show()
        self.user_frame.show()
        self.layout.addWidget(self.top_frame,1)
        self.layout.addWidget(self.user_frame, 2)
        self.setLayout(self.layout)
Exemple #15
0
    def __init__(self, server, args):
        self.server = server
        self.tornado_server = None
        self.api_cache = {}
        self.registered_base_handlers = []

        # Set Up Websocket and Authorization Managers
        self.wsm = WebsocketManager(server)
        self.auth = Authorization(args.apikey)

        mimetypes.add_type('text/plain', '.log')
        mimetypes.add_type('text/plain', '.gcode')
        mimetypes.add_type('text/plain', '.cfg')

        # Set up HTTP only requests
        self.mutable_router = MutableRouter(self)
        app_handlers = [(AnyMatches(), self.mutable_router),
                        (r"/websocket", WebSocket, {
                            'wsm': self.wsm,
                            'auth': self.auth
                        }),
                        (r"/api/version", EmulateOctoprintHandler, {
                            'server': server,
                            'auth': self.auth
                        })]

        self.app = tornado.web.Application(app_handlers,
                                           serve_traceback=args.debug,
                                           websocket_ping_interval=10,
                                           websocket_ping_timeout=30,
                                           enable_cors=False)
        self.get_handler_delegate = self.app.get_handler_delegate

        # Register handlers
        self.register_static_file_handler("moonraker.log", args.logfile)
        self.auth.register_handlers(self)
Exemple #16
0
class MoonrakerApp:
    def __init__(self, server, args):
        self.server = server
        self.tornado_server = None
        self.api_cache = {}
        self.registered_base_handlers = []

        # Set Up Websocket and Authorization Managers
        self.wsm = WebsocketManager(server)
        self.auth = Authorization(args.apikey)

        mimetypes.add_type('text/plain', '.log')
        mimetypes.add_type('text/plain', '.gcode')
        mimetypes.add_type('text/plain', '.cfg')

        # Set up HTTP only requests
        self.mutable_router = MutableRouter(self)
        app_handlers = [(AnyMatches(), self.mutable_router),
                        (r"/websocket", WebSocket, {
                            'wsm': self.wsm,
                            'auth': self.auth
                        }),
                        (r"/api/version", EmulateOctoprintHandler, {
                            'server': server,
                            'auth': self.auth
                        })]

        self.app = tornado.web.Application(app_handlers,
                                           serve_traceback=args.debug,
                                           websocket_ping_interval=10,
                                           websocket_ping_timeout=30,
                                           enable_cors=False)
        self.get_handler_delegate = self.app.get_handler_delegate

        # Register handlers
        self.register_static_file_handler("moonraker.log", args.logfile)
        self.auth.register_handlers(self)

    def listen(self, host, port):
        self.tornado_server = self.app.listen(port,
                                              address=host,
                                              max_body_size=MAX_UPLOAD_SIZE,
                                              xheaders=True)

    async def close(self):
        if self.tornado_server is not None:
            self.tornado_server.stop()
        await self.wsm.close()
        self.auth.close()

    def load_config(self, config):
        if 'enable_cors' in config:
            self.app.settings['enable_cors'] = config['enable_cors']
        self.auth.load_config(config)

    def register_remote_handler(self, endpoint):
        if endpoint in RESERVED_ENDPOINTS:
            return
        api_def = self.api_cache.get(endpoint,
                                     self._create_api_definition(endpoint))
        if api_def.uri in self.registered_base_handlers:
            # reserved handler or already registered
            return
        logging.info("Registering remote endpoint: (%s) %s" %
                     (" ".join(api_def.request_methods), api_def.uri))
        self.wsm.register_handler(api_def)
        params = {}
        params['server'] = self.server
        params['auth'] = self.auth
        params['methods'] = api_def.request_methods
        params['arg_parser'] = api_def.parser
        params['remote_callback'] = api_def.endpoint
        self.mutable_router.add_handler(api_def.uri, RemoteRequestHandler,
                                        params)
        self.registered_base_handlers.append(api_def.uri)

    def register_local_handler(self,
                               uri,
                               ws_method,
                               request_methods,
                               callback,
                               http_only=False):
        if uri in self.registered_base_handlers:
            return
        api_def = self._create_api_definition(uri, ws_method, request_methods)
        logging.info("Registering local endpoint: (%s) %s" %
                     (" ".join(request_methods), uri))
        if not http_only:
            self.wsm.register_handler(api_def, callback)
        params = {}
        params['server'] = self.server
        params['auth'] = self.auth
        params['methods'] = request_methods
        params['arg_parser'] = api_def.parser
        params['callback'] = callback
        self.mutable_router.add_handler(uri, LocalRequestHandler, params)
        self.registered_base_handlers.append(uri)

    def register_static_file_handler(self,
                                     pattern,
                                     file_path,
                                     can_delete=False,
                                     op_check_cb=None):
        if pattern[0] != "/":
            pattern = "/server/files/" + pattern
        if os.path.isfile(file_path):
            pattern += '()'
        elif os.path.isdir(file_path):
            if pattern[-1] != "/":
                pattern += "/"
            pattern += "(.*)"
        else:
            logging.info("Invalid file path: %s" % (file_path))
            return
        methods = ['GET']
        if can_delete:
            methods.append('DELETE')
        params = {
            'server': self.server,
            'auth': self.auth,
            'path': file_path,
            'methods': methods,
            'op_check_cb': op_check_cb
        }
        self.mutable_router.add_handler(pattern, FileRequestHandler, params)

    def register_upload_handler(self, pattern):
        params = {'server': self.server, 'auth': self.auth}
        self.mutable_router.add_handler(pattern, FileUploadHandler, params)

    def remove_handler(self, endpoint):
        api_def = self.api_cache.get(endpoint)
        if api_def is not None:
            self.wsm.remove_handler(api_def.uri)
            self.mutable_router.remove_handler(api_def.ws_method)

    def _create_api_definition(self,
                               endpoint,
                               ws_method=None,
                               request_methods=['GET', 'POST']):
        if endpoint in self.api_cache:
            return self.api_cache[endpoint]
        if endpoint[0] == '/':
            uri = endpoint
        else:
            uri = "/printer/" + endpoint
        if ws_method is None:
            ws_method = uri[1:].replace('/', '_')
        if endpoint.startswith("objects/"):
            parser = _status_parser
        else:
            parser = _default_parser
        api_def = APIDefinition(endpoint, uri, ws_method, request_methods,
                                parser)
        self.api_cache[endpoint] = api_def
        return api_def
Exemple #17
0
 def testPassCase(self): # неправильный пароль - в другом регистре
         test_name = "TestUser"
         test_pass = "******"
         test_code = -102
         real_code = Authorization.login(test_name, test_pass)
         self.assertEqual(test_code, real_code)
Exemple #18
0
class MoonrakerApp:
    def __init__(self, config):
        self.server = config.get_server()
        self.tornado_server = None
        self.api_cache = {}
        self.registered_base_handlers = []
        self.max_upload_size = config.getint('max_upload_size', 1024)
        self.max_upload_size *= 1024 * 1024

        # Set Up Websocket and Authorization Managers
        self.wsm = WebsocketManager(self.server)
        self.auth = Authorization(config['authorization'])

        mimetypes.add_type('text/plain', '.log')
        mimetypes.add_type('text/plain', '.gcode')
        mimetypes.add_type('text/plain', '.cfg')
        debug = config.getboolean('enable_debug_logging', False)
        log_level = logging.DEBUG if debug else logging.INFO
        logging.getLogger().setLevel(log_level)
        app_args = {
            'serve_traceback': debug,
            'websocket_ping_interval': 10,
            'websocket_ping_timeout': 30,
            'parent': self,
            'default_handler_class': AuthorizedErrorHandler,
            'default_handler_args': {}
        }
        if not debug:
            app_args['log_function'] = self.log_release_mode

        # Set up HTTP only requests
        self.mutable_router = MutableRouter(self)
        app_handlers = [(AnyMatches(), self.mutable_router),
                        (r"/websocket", WebSocket)]
        self.app = tornado.web.Application(app_handlers, **app_args)
        self.get_handler_delegate = self.app.get_handler_delegate

        # Register handlers
        logfile = config['system_args'].get('logfile')
        if logfile:
            self.register_static_file_handler("moonraker.log",
                                              logfile,
                                              force=True)
        self.register_static_file_handler("klippy.log",
                                          DEFAULT_KLIPPY_LOG_PATH,
                                          force=True)
        self.auth.register_handlers(self)

    def listen(self, host, port):
        self.tornado_server = self.app.listen(port,
                                              address=host,
                                              max_body_size=MAX_BODY_SIZE,
                                              xheaders=True)

    def log_release_mode(self, handler):
        status_code = handler.get_status()
        if status_code in [200, 204]:
            # don't log OK and No Content
            return
        if status_code < 400:
            log_method = access_log.info
        elif status_code < 500:
            log_method = access_log.warning
        else:
            log_method = access_log.error
        request_time = 1000.0 * handler.request.request_time()
        log_method("%d %s %.2fms", status_code, handler._request_summary(),
                   request_time)

    def get_server(self):
        return self.server

    def get_auth(self):
        return self.auth

    def get_websocket_manager(self):
        return self.wsm

    async def close(self):
        if self.tornado_server is not None:
            self.tornado_server.stop()
            await self.tornado_server.close_all_connections()
        await self.wsm.close()
        self.auth.close()

    def register_remote_handler(self, endpoint):
        if endpoint in RESERVED_ENDPOINTS:
            return
        api_def = self._create_api_definition(endpoint)
        if api_def.uri in self.registered_base_handlers:
            # reserved handler or already registered
            return
        logging.info(
            f"Registering remote endpoint - "
            f"HTTP: ({' '.join(api_def.request_methods)}) {api_def.uri}; "
            f"Websocket: {', '.join(api_def.ws_methods)}")
        self.wsm.register_remote_handler(api_def)
        params = {}
        params['methods'] = api_def.request_methods
        params['callback'] = api_def.endpoint
        params['need_object_parser'] = api_def.need_object_parser
        self.mutable_router.add_handler(api_def.uri, DynamicRequestHandler,
                                        params)
        self.registered_base_handlers.append(api_def.uri)

    def register_local_handler(self,
                               uri,
                               request_methods,
                               callback,
                               protocol=["http", "websocket"],
                               wrap_result=True):
        if uri in self.registered_base_handlers:
            return
        api_def = self._create_api_definition(uri,
                                              request_methods,
                                              is_remote=False)
        msg = "Registering local endpoint"
        if "http" in protocol:
            msg += f" - HTTP: ({' '.join(request_methods)}) {uri}"
            params = {}
            params['methods'] = request_methods
            params['callback'] = callback
            params['wrap_result'] = wrap_result
            params['is_remote'] = False
            self.mutable_router.add_handler(uri, DynamicRequestHandler, params)
            self.registered_base_handlers.append(uri)
        if "websocket" in protocol:
            msg += f" - Websocket: {', '.join(api_def.ws_methods)}"
            self.wsm.register_local_handler(api_def, callback)
        logging.info(msg)

    def register_static_file_handler(self, pattern, file_path, force=False):
        if pattern[0] != "/":
            pattern = "/server/files/" + pattern
        if os.path.isfile(file_path) or force:
            pattern += '()'
        elif os.path.isdir(file_path):
            if pattern[-1] != "/":
                pattern += "/"
            pattern += "(.*)"
        else:
            logging.info(f"Invalid file path: {file_path}")
            return
        logging.debug(f"Registering static file: ({pattern}) {file_path}")
        params = {'path': file_path}
        self.mutable_router.add_handler(pattern, FileRequestHandler, params)

    def register_upload_handler(self, pattern):
        self.mutable_router.add_handler(
            pattern, FileUploadHandler,
            {'max_upload_size': self.max_upload_size})

    def remove_handler(self, endpoint):
        api_def = self.api_cache.get(endpoint)
        if api_def is not None:
            self.wsm.remove_handler(api_def.uri)
            self.mutable_router.remove_handler(api_def.ws_method)

    def _create_api_definition(self,
                               endpoint,
                               request_methods=[],
                               is_remote=True):
        if endpoint in self.api_cache:
            return self.api_cache[endpoint]
        if endpoint[0] == '/':
            uri = endpoint
        elif is_remote:
            uri = "/printer/" + endpoint
        else:
            uri = "/server/" + endpoint
        ws_methods = []
        if is_remote:
            # Remote requests accept both GET and POST requests.  These
            # requests execute the same callback, thus they resolve to
            # only a single websocket method.
            ws_methods.append(uri[1:].replace('/', '.'))
            request_methods = ['GET', 'POST']
        else:
            name_parts = uri[1:].split('/')
            if len(request_methods) > 1:
                for req_mthd in request_methods:
                    func_name = req_mthd.lower() + "_" + name_parts[-1]
                    ws_methods.append(".".join(name_parts[:-1] + [func_name]))
            else:
                ws_methods.append(".".join(name_parts))
        if not is_remote and len(request_methods) != len(ws_methods):
            raise self.server.error(
                "Invalid API definition.  Number of websocket methods must "
                "match the number of request methods")
        need_object_parser = endpoint.startswith("objects/")
        api_def = APIDefinition(endpoint, uri, ws_methods, request_methods,
                                need_object_parser)
        self.api_cache[endpoint] = api_def
        return api_def
Exemple #19
0
 def __init__(self, params=None):
     Header.__init__(self, params)
     self.name = "Proxy-Authorization"
     self.auth = Authorization()
     self.value = self.generate_valid_value()
Exemple #20
0
 def testBadLogin(self): # неправильный логин
         test_name = "UserNotExist"
         test_pass = "******"
         test_code = -101
         real_code = Authorization.login(test_name, test_pass)
         self.assertEqual(test_code, real_code)
Exemple #21
0
 def testEmptyLogin(self): # пустой логин
         test_name = ''
         test_pass = "******"
         test_code = -101
         real_code = Authorization.login(test_name, test_pass)
         self.assertEqual(test_code, real_code)
Exemple #22
0
class MoonrakerApp:
    def __init__(self, config):
        self.server = config.get_server()
        self.tornado_server = None
        self.api_cache = {}
        self.registered_base_handlers = []
        self.max_upload_size = config.getint('max_upload_size', 200)
        self.max_upload_size *= 1024 * 1024

        # Set Up Websocket and Authorization Managers
        self.wsm = WebsocketManager(self.server)
        self.auth = Authorization(config['authorization'])

        mimetypes.add_type('text/plain', '.log')
        mimetypes.add_type('text/plain', '.gcode')
        mimetypes.add_type('text/plain', '.cfg')
        debug = config.getboolean('enable_debug_logging', True)

        # Set up HTTP only requests
        self.mutable_router = MutableRouter(self)
        app_handlers = [(AnyMatches(), self.mutable_router),
                        (r"/websocket", WebSocket),
                        (r"/api/version", EmulateOctoprintHandler)]

        self.app = tornado.web.Application(app_handlers,
                                           serve_traceback=debug,
                                           websocket_ping_interval=10,
                                           websocket_ping_timeout=30,
                                           parent=self)
        self.get_handler_delegate = self.app.get_handler_delegate

        # Register handlers
        logfile = config['cmd_args'].get('logfile')
        self.register_static_file_handler("moonraker.log", logfile)
        self.auth.register_handlers(self)

    def listen(self, host, port):
        self.tornado_server = self.app.listen(
            port,
            address=host,
            max_body_size=self.max_upload_size,
            xheaders=True)

    def get_server(self):
        return self.server

    def get_auth(self):
        return self.auth

    def get_websocket_manager(self):
        return self.wsm

    async def close(self):
        if self.tornado_server is not None:
            self.tornado_server.stop()
            await self.tornado_server.close_all_connections()
        await self.wsm.close()
        self.auth.close()

    def register_remote_handler(self, endpoint):
        if endpoint in RESERVED_ENDPOINTS:
            return
        api_def = self._create_api_definition(endpoint)
        if api_def.uri in self.registered_base_handlers:
            # reserved handler or already registered
            return
        logging.info(
            f"Registering remote endpoint - "
            f"HTTP: ({' '.join(api_def.request_methods)}) {api_def.uri}; "
            f"Websocket: {', '.join(api_def.ws_methods)}")
        self.wsm.register_remote_handler(api_def)
        params = {}
        params['arg_parser'] = api_def.parser
        params['remote_callback'] = api_def.endpoint
        self.mutable_router.add_handler(api_def.uri, RemoteRequestHandler,
                                        params)
        self.registered_base_handlers.append(api_def.uri)

    def register_local_handler(self,
                               uri,
                               request_methods,
                               callback,
                               protocol=["http", "websocket"]):
        if uri in self.registered_base_handlers:
            return
        api_def = self._create_api_definition(uri,
                                              request_methods,
                                              is_remote=False)
        msg = "Registering local endpoint"
        if "http" in protocol:
            msg += f" - HTTP: ({' '.join(request_methods)}) {uri}"
            params = {}
            params['methods'] = request_methods
            params['arg_parser'] = api_def.parser
            params['callback'] = callback
            self.mutable_router.add_handler(uri, LocalRequestHandler, params)
            self.registered_base_handlers.append(uri)
        if "websocket" in protocol:
            msg += f" - Websocket: {', '.join(api_def.ws_methods)}"
            self.wsm.register_local_handler(api_def, callback)
        logging.info(msg)

    def register_static_file_handler(self, pattern, file_path):
        if pattern[0] != "/":
            pattern = "/server/files/" + pattern
        if os.path.isfile(file_path):
            pattern += '()'
        elif os.path.isdir(file_path):
            if pattern[-1] != "/":
                pattern += "/"
            pattern += "(.*)"
        else:
            logging.info(f"Invalid file path: {file_path}")
            return
        logging.debug(f"Registering static file: ({pattern}) {file_path}")
        params = {'path': file_path}
        self.mutable_router.add_handler(pattern, FileRequestHandler, params)

    def register_upload_handler(self, pattern):
        self.mutable_router.add_handler(pattern, FileUploadHandler, {})

    def remove_handler(self, endpoint):
        api_def = self.api_cache.get(endpoint)
        if api_def is not None:
            self.wsm.remove_handler(api_def.uri)
            self.mutable_router.remove_handler(api_def.ws_method)

    def _create_api_definition(self,
                               endpoint,
                               request_methods=[],
                               is_remote=True):
        if endpoint in self.api_cache:
            return self.api_cache[endpoint]
        if endpoint[0] == '/':
            uri = endpoint
        elif is_remote:
            uri = "/printer/" + endpoint
        else:
            uri = "/server/" + endpoint
        ws_methods = []
        if is_remote:
            # Remote requests accept both GET and POST requests.  These
            # requests execute the same callback, thus they resolve to
            # only a single websocket method.
            ws_methods.append(uri[1:].replace('/', '.'))
            request_methods = ['GET', 'POST']
        else:
            name_parts = uri[1:].split('/')
            if len(request_methods) > 1:
                for req_mthd in request_methods:
                    func_name = req_mthd.lower() + "_" + name_parts[-1]
                    ws_methods.append(".".join(name_parts[:-1] + [func_name]))
            else:
                ws_methods.append(".".join(name_parts))
        if not is_remote and len(request_methods) != len(ws_methods):
            raise self.server.error(
                "Invalid API definition.  Number of websocket methods must "
                "match the number of request methods")
        if endpoint.startswith("objects/"):
            parser = _status_parser
        else:
            parser = _default_parser

        api_def = APIDefinition(endpoint, uri, ws_methods, request_methods,
                                parser)
        self.api_cache[endpoint] = api_def
        return api_def
Exemple #23
0
 def testPassCase(self):  # неправильный пароль - в другом регистре
     test_name = "TestUser"
     test_pass = "******"
     test_code = -102
     real_code = Authorization.login(test_name, test_pass)
     self.assertEqual(test_code, real_code)
Exemple #24
0
 def testLoginCase(self):  # правильный логин - в другом регистре
     test_name = "testuser"
     test_pass = "******"
     test_code = -101
     real_code = Authorization.login(test_name, test_pass)
     self.assertEqual(test_code, real_code)
Exemple #25
0
 def testEmptyPass(self):  # пустой пароль
     test_name = "TestUser"
     test_pass = ''
     test_code = -102
     real_code = Authorization.login(test_name, test_pass)
     self.assertEqual(test_code, real_code)
Exemple #26
0
 def testBadPass(self): # неправильный пароль
         test_name = "TestUser"
         test_pass = "******"
         test_code = -102
         real_code = Authorization.login(test_name, test_pass)
         self.assertEqual(test_code, real_code)
Exemple #27
0
 def testBadLogin(self):  # неправильный логин
     test_name = "UserNotExist"
     test_pass = "******"
     test_code = -101
     real_code = Authorization.login(test_name, test_pass)
     self.assertEqual(test_code, real_code)
Exemple #28
0
 def testBadPass(self):  # неправильный пароль
     test_name = "TestUser"
     test_pass = "******"
     test_code = -102
     real_code = Authorization.login(test_name, test_pass)
     self.assertEqual(test_code, real_code)
def test_authorized_if_calendar_user_in_list_using_calendar_data(
        authorization: Authorization) -> None:
    data = {"users": [EXISTING_USERNAME]}
    assert authorization.can_access(username=EXISTING_USERNAME,
                                    data=data) is True
import urllib3
import sys
from authorization import Authorization
from employee import Employee
from erp_organization import Organization
from workspace import Workspace
from dbconnect import DBConnect
urllib3.disable_warnings()

env = sys.argv[1]
space_name = sys.argv[2]
email = sys.argv[3]

new_space = Workspace(env)
new_space_admin = Employee(env)
db = DBConnect(env)

space_guid = new_space.create_workspace(space_name=space_name,
                                        space_code=space_name)
new_space_admin.create_admin_for_new_space(space_guid, email)

auth = Authorization(env)
headers = auth.create_headers(email)
new_organization_guid = Organization(env, headers).add_organization('Owner')
new_space.set_space_owner(new_organization_guid)

new_space_admin.add_admin_to_employees(new_organization_guid, headers)
print(space_guid, space_name, email)
Exemple #31
0
 def testLoginCase(self): # правильный логин - в другом регистре
         test_name = "testuser"
         test_pass = "******"
         test_code = -101
         real_code = Authorization.login(test_name, test_pass)
         self.assertEqual(test_code, real_code)
    def __init__(self, env, headers):
        self._base_url = base_url_from_env(env)
        self._headers = headers
        self._spaceGuid = headers['SpaceGuid']

    def add_organization(self, organization_title):
        url = self._base_url + 'ctms/api/v1/organizations/create'
        data = {
            'statusGuid': '655aa6f2-434a-4b8d-8254-722d160e611e',  # Active
            'categoryGuid': 'b6b010d3-2a9b-4e93-8db8-01cd6056b713',  # CRO
            'countryGuid': '2876aae7-b8f5-4a35-bf61-9ad69f12ccc0',  # Russia
            'spaceGuid': self._spaceGuid,
            'name': organization_title,
            'addresses': [],
            'createdByGuid': '1d99e18d-a366-4b91-956e-1388463ba09f'
        }
        response = requests.post(url, headers=self._headers, json=data, verify=False)
        if response.status_code != 200:
            print(response.status_code, response.text)
            raise Exception('Не удалось создать организацию')
        else:
            organization_guid = response.json()['GuidCode']
        return organization_guid


if __name__ == '__main__':
    from authorization import Authorization
    headers_for_test = Authorization('test').create_headers('*****@*****.**', 'somepwd')
    new_organization_guid = Organization('test', headers_for_test).add_organization('test_4111')
    print(new_organization_guid)
Exemple #33
0
 def testEmptyPass(self): # пустой пароль
         test_name = "TestUser"
         test_pass = ''
         test_code = -102
         real_code = Authorization.login(test_name, test_pass)
         self.assertEqual(test_code, real_code)
def test_authorized_if_calendar_user_in_list(
        authorization: Authorization) -> None:
    assert authorization.can_access(username=EXISTING_USERNAME,
                                    calendar_id="sample_data_file") is True
Exemple #35
0
db = DBConnect(env)

while True:
    space_name = input("Введите Имя Спейса (должно быть уникальным): ")
    if space_name.lower() in db.space_codes_on_server():
        print("Пространство с таким именем уже сущестует. Введите другое имя")
        continue
    break

while True:
    email = input("Введите валидный email (логин должен быть уникальным в рамках всех спейсов): ")
    if new_space_admin.login_exists(email):
        print("Логин занят")
        continue
    break

space_guid = new_space.create_workspace(space_name=space_name, space_code=space_name)
new_space_admin.create_admin_for_new_space(space_guid, email, DEFAULT_ADMIN_PASSWORD)
print(f"\n\nСпейс {space_name} создан. Логин - {email}, Пароль - {DEFAULT_ADMIN_PASSWORD}")

auth = Authorization(env)
headers = auth.create_headers(email, password=DEFAULT_ADMIN_PASSWORD)

new_organization_guid = Organization(env, headers).add_organization(DEFAULT_FIRST_ORGANIZATION_TITLE)
print(f"В спейсе с Guid-кодом - {space_guid} создана организация {DEFAULT_FIRST_ORGANIZATION_TITLE}")
new_space.set_space_owner(new_organization_guid)

new_space_admin.add_admin_to_employees(new_organization_guid, headers)

input("Press any key to exit")
def test_unauthorized_if_calendar_user_not_in_list(
        authorization: Authorization) -> None:
    assert authorization.can_access(username="******",
                                    calendar_id="sample_data_file") is False
Exemple #37
0
 def testEmptyLogin(self):  # пустой логин
     test_name = ''
     test_pass = "******"
     test_code = -101
     real_code = Authorization.login(test_name, test_pass)
     self.assertEqual(test_code, real_code)
def authorization() -> Authorization:
    return Authorization(calendar_data=CalendarData("test/fixtures"))