lesscode-flask 0.0.27__tar.gz → 0.0.31__tar.gz

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lesscode-flask
-Version: 0.0.27
+Version: 0.0.31
 Summary: lesscode-flask 是基于flask的web开发脚手架项目，该项目初衷为简化开发过程，让研发人员更加关注业务。
 Home-page: https://lesscode-flask
 Author: Chao.yy
@@ -31,7 +31,6 @@ Requires-Dist: pystache==0.6.5
 Requires-Dist: flask-swagger-ui==4.11.1
 Requires-Dist: lesscode-utils==0.0.61
 Requires-Dist: Flask-Login==0.6.3
-Requires-Dist: gevent==24.2.1
 
 # lesscode-flask
 

lesscode_flask-0.0.31/lesscode_flask/__init__.py

@@ -0,0 +1,55 @@
+__version__ = '0.0.31'
+
+import functools
+import logging
+import traceback
+
+from flask import Blueprint
+from lesscode_flask.utils.decorator.cache import deal_cache
+
+
+class SQ_Blueprint(Blueprint):
+    def __init__(self, name: str, url_prefix: str, **kwargs):
+        if not kwargs.get("import_name"):
+            kwargs["import_name"] = __name__
+        super().__init__(name=name, url_prefix=url_prefix, **kwargs)
+
+    def decorator_handler(self, title: str, url: str = None, cache_enalbe: bool = False, cache_ex: int = 3600 * 10,
+                          content_type: str = "json", methods=['POST']):
+        options = {"methods": methods}
+
+        def decorator(func):
+            path = url if url else "/{}".format(func.__name__)
+
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                # 如果开启了缓存开关
+                if cache_enalbe:
+                    # 尝试从缓存中获取数据
+                    try:
+                        data = deal_cache(func, cache_ex, "", *args, **kwargs)
+                    except Exception as e:
+                        logging.error(traceback.format_exc())
+                        data = func(*args, **kwargs)
+                    return data
+                # 如果没有开启缓存，或者缓存未命中，则执行原始函数
+                data = func(*args, **kwargs)
+                return data
+
+            # 添加 URL 规则到 Flask 路由
+            self.add_url_rule(path, None, wrapper, **options)
+            return wrapper
+
+        decorator._title = title
+        decorator._request_type = content_type
+        return decorator
+
+    def post_route(self, title: str, url: str = None, cache_enalbe: bool = False, cache_ex: int = 3600 * 10,
+                   content_type: str = "json", methods=['POST']):
+        decorator = self.decorator_handler(title, url, cache_enalbe, cache_ex, content_type, methods)
+        return decorator
+
+    def get_route(self, title: str, url: str = None, cache_enalbe: bool = False, cache_ex: int = 3600 * 10,
+                  content_type: str = "json", methods=['GET']):
+        decorator = self.decorator_handler(title, url, cache_enalbe, cache_ex, content_type, methods)
+        return decorator

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/lesscode_flask/app.py

@@ -121,24 +121,25 @@ def create_app():
         request.request_id = request_id
         # 记录请求开始时间
         request_start_time[request_id] = time.time()
-        # 获取当前请求的url
-        url = request.path
-        # 获取URL 对应的id 与访问权限
-        id, access = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hmget(f"upms:url_info:{url}",
-                                                                                        ["id", "access"])
-        if not id:
-            # 如果没有进行注册的url 默认需要登录权限
-            access = app_config.get("AUTH_DEFAULT_ACCESS", "0")
-        # '访问权限2：需要权限 1：需要登录 0：游客',
-        if str(access) == "1":  # 需要登录
-            if current_user.is_anonymous_user:
-                # abort(403, "需要登录")
-                ResponseResult.fail("请登录后访问", status_code="403")
-        elif str(access) == "2":  # 需要权限
-            if current_user.is_anonymous_user:
-                ResponseResult.fail("请登录后访问", status_code="403")
-            if not current_user.has_permission(id):
-                ResponseResult.fail("请获取授权后访问", status_code="403")
+        if app.config.get("AUTHORIZATION_ENABLE"):  # 启动 AUTHORIZATION_ENABLE 才进行权限验证
+            # 获取当前请求的url
+            url = request.path
+            # 获取URL 对应的id 与访问权限
+            id, access = RedisHelper(app_config.get("REDIS_OAUTH_KEY", "redis")).sync_hmget(f"upms:url_info:{url}",
+                                                                                            ["id", "access"])
+            if not id:
+                # 如果没有进行注册的url 默认需要登录权限
+                access = app_config.get("AUTH_DEFAULT_ACCESS", "0")
+            # '访问权限2：需要权限 1：需要登录 0：游客',
+            if str(access) == "1":  # 需要登录
+                if current_user.is_anonymous_user:
+                    # abort(403, "需要登录")
+                    ResponseResult.fail("请登录后访问", status_code="403")
+            elif str(access) == "2":  # 需要权限
+                if current_user.is_anonymous_user:
+                    ResponseResult.fail("请登录后访问", status_code="403")
+                if not current_user.has_permission(id):
+                    ResponseResult.fail("请获取授权后访问", status_code="403")
 
     @app.after_request
     def after_request(response):

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/lesscode_flask/model/response_result.py

@@ -35,7 +35,7 @@ class ResponseResult(dict):
         return respone
 
     @staticmethod
-    def success(data,message: str=None):
+    def success(data, message: str = None):
         """
         成功返回结果
         :param data:

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/lesscode_flask/service/base_service.py

@@ -1,9 +1,10 @@
 import logging
 
 from flask_login import current_user
+
 from lesscode_flask.db import db
 from lesscode_flask.model.base_model import BaseModel
-from lesscode_flask.utils.helpers import serialize_result_to_dict, parameter_validation
+from lesscode_flask.utils.helpers import serialize_result_to_dict, parameter_validation, alchemy_result_to_dict
 
 logger = logging.getLogger(__name__)
 
@@ -100,31 +101,60 @@ class BaseService:
         item = query.one()
         return item
 
-    def get_items(self, filters: list = None):
+    def get_items(self, select_columns: list = None, order_columns: list = None, filters: list = None, offset: int = 0,
+                  size: int = 10):
         """
         获取列表信息
+        :param select_columns:
+        :param order_columns:
         :param filters:
+        :param offset:
+        :param size:
         :return:
         """
         query = self.model.query
         if filters:
             query = query.filter(*filters)
-        items = query.all()
-        return items
+        if order_columns:
+            query = query.order_by(*order_columns)
+        if offset > 0:
+            query = query.offset(offset).limit(size)
+        if select_columns:
+            query = query.with_entities(*select_columns)
+            data = alchemy_result_to_dict(query.all())
+        else:
+            data = serialize_result_to_dict(query.all())
+        return data
 
     def delete_item(self, id: str):
-        self.model.query.filter_by(id=id).delete()
-        return id
+        return self.model.query.filter_by(id=id).delete()
 
     def delete_items(self, filters: list):
         if filters and len(filters) > 0:
-            self.model.query.filter(*filters).delete()
-        return id
+            return self.model.query.filter(*filters).delete()
+        return 0
 
-    def page(self, columns: [], filters: list = None, page_num: int = 1, page_size: int = 10):
+    def page(self, select_columns: list = None, columns: list = None, order_columns: list = None, filters: list = None,
+             page_num: int = 1,
+             page_size: int = 10):
+        """
+        分页查询
+        :param select_columns:
+        :param columns:
+        :param order_columns:
+        :param filters:
+        :param page_num:
+        :param page_size:
+        :return:
+        """
         query = self.model.query
         if filters:
             query = query.filter(*filters)
+        if order_columns:
+            query = query.order_by(*order_columns)
+        if select_columns:
+            query = query.with_entities(*select_columns)
+
         pagination = query.paginate(page=page_num, per_page=page_size)
         # 获取当前页的数据
         items = pagination.items
@@ -132,7 +162,13 @@ class BaseService:
         total = pagination.total
         has_prev = pagination.has_prev
         has_next = pagination.has_next
-        result = {"columns": columns, "dataSource": serialize_result_to_dict(items), "total": total,
+        if select_columns:
+            data = alchemy_result_to_dict(items)
+        else:
+            data = serialize_result_to_dict(items)
+        result = {"columns": columns, "dataSource": data, "total": total,
                   "has_prev": has_prev,
                   "has_next": has_next}
+        if columns:
+            result["columns"] = columns
         return result

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/lesscode_flask/setting/__init__.py

@@ -66,7 +66,8 @@ class BaseConfig:
     # redis缓存开关
     CACHE_ENABLE: bool = False
     REDIS_CACHE_KEY = "redis"
-    REDIS_OAUTH_KEY = None
+    REDIS_OAUTH_KEY = "redis"
+    AUTHORIZATION_ENABLE: bool = False
     #
     # # 外网地址
     # OUTSIDE_SCREEN_IP: str = ""

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/lesscode_flask/setup/__init__.py

@@ -112,7 +112,8 @@ def setup_sql_alchemy(app):
     :param app:
     :return:
     """
-    db.init_app(app)
+    if app.config.get("SQLALCHEMY_BINDS"): # 确保配置SQLALCHEMY_BINDS才注册SQLAlchemy
+        db.init_app(app)
 
 
 def setup_login_manager(app):

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/lesscode_flask/utils/helpers.py

@@ -25,6 +25,29 @@ def serialize_result_to_dict(result):
     return {k: v for k, v in result.__dict__.items() if not k.startswith('_')}
 
 
+def alchemy_result_to_dict(result):
+    """
+    alchemy 指定字段查询后返回的数据解析为字典
+    :param result:
+    :return:
+    """
+    data_list = []
+    if not result:
+        return result
+    if isinstance(result, list):
+        key_list = list(result[0]._fields)
+        for d in result:
+            dict_data = dict(zip(key_list, d))
+            data_list.append(dict_data)
+        return data_list
+    else:
+        if result:
+            key_list = list(result._fields)
+            return dict(zip(key_list, result))
+        else:
+            return {}
+
+
 def generate_uuid():
     """
     生成UUID
@@ -106,21 +129,21 @@ def inject_args(req, func, view_args={}):
         # 兼容**kwargs 参数
         if parameter.kind == inspect.Parameter.VAR_KEYWORD:
             argument_value = kwargs
-        if argument_value:
-            # 获取形参类型
-            parameter_type = parameter.annotation
-            # 形参类型为空，尝试获取形参默认值类型
-            if parameter_type is inspect.Parameter.empty:
-                parameter_type = type(parameter.default)
-            if parameter_type == int:
-                params_dict[parameter_name] = int(argument_value)
-            elif parameter_type == float:
-                params_dict[parameter_name] = float(argument_value)
-            elif parameter_type == bool:
-                params_dict[parameter_name] = parse_boolean(argument_value)
-            else:
-                # 其余都按str处理
-                params_dict[parameter_name] = argument_value
+        # if argument_value:
+        # 获取形参类型
+        parameter_type = parameter.annotation
+        # 形参类型为空，尝试获取形参默认值类型
+        if parameter_type is inspect.Parameter.empty:
+            parameter_type = type(parameter.default)
+        if parameter_type == int:
+            params_dict[parameter_name] = int(argument_value)
+        elif parameter_type == float:
+            params_dict[parameter_name] = float(argument_value)
+        elif parameter_type == bool:
+            params_dict[parameter_name] = parse_boolean(argument_value)
+        else:
+            # 其余都按str处理
+            params_dict[parameter_name] = argument_value
     return params_dict
 
 
@@ -136,4 +159,3 @@ def mustache_render(template, **kwargs):
     template = Template(template)
     # 渲染模板
     return template.render(**kwargs)
-

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/lesscode_flask.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lesscode-flask
-Version: 0.0.27
+Version: 0.0.31
 Summary: lesscode-flask 是基于flask的web开发脚手架项目，该项目初衷为简化开发过程，让研发人员更加关注业务。
 Home-page: https://lesscode-flask
 Author: Chao.yy
@@ -31,7 +31,6 @@ Requires-Dist: pystache==0.6.5
 Requires-Dist: flask-swagger-ui==4.11.1
 Requires-Dist: lesscode-utils==0.0.61
 Requires-Dist: Flask-Login==0.6.3
-Requires-Dist: gevent==24.2.1
 
 # lesscode-flask
 

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/lesscode_flask.egg-info/SOURCES.txt

@@ -41,9 +41,11 @@ lesscode_flask/utils/swagger/swagger_template.py
 lesscode_flask/utils/swagger/swagger_util.py
 redash/query_runner/__init__.py
 redash/query_runner/clickhouse.py
+redash/query_runner/elasticsearch.py
 redash/query_runner/kingbase.py
 redash/query_runner/mysql.py
 redash/query_runner/pg.py
 redash/settings/__init__.py
 redash/settings/helpers.py
+redash/utils/__init__.py
 redash/utils/requests_session.py

{lesscode_flask-0.0.27 → lesscode_flask-0.0.31}/lesscode_flask.egg-info/requires.txt

@@ -19,4 +19,3 @@ pystache==0.6.5
 flask-swagger-ui==4.11.1
 lesscode-utils==0.0.61
 Flask-Login==0.6.3
-gevent==24.2.1

lesscode_flask-0.0.31/redash/query_runner/elasticsearch.py

@@ -0,0 +1,515 @@
+import logging
+import sys
+import urllib.request
+import urllib.parse
+import urllib.error
+
+import requests
+from requests.auth import HTTPBasicAuth
+
+from redash.query_runner import *
+from redash.utils import json_dumps, json_loads
+
+try:
+    import http.client as http_client
+except ImportError:
+    # Python 2
+    import http.client as http_client
+
+logger = logging.getLogger(__name__)
+
+ELASTICSEARCH_TYPES_MAPPING = {
+    "integer": TYPE_INTEGER,
+    "long": TYPE_INTEGER,
+    "float": TYPE_FLOAT,
+    "double": TYPE_FLOAT,
+    "boolean": TYPE_BOOLEAN,
+    "string": TYPE_STRING,
+    "date": TYPE_DATE,
+    "object": TYPE_STRING,
+    # "geo_point" TODO: Need to split to 2 fields somehow
+}
+
+ELASTICSEARCH_BUILTIN_FIELDS_MAPPING = {"_id": "Id", "_score": "Score"}
+
+PYTHON_TYPES_MAPPING = {
+    str: TYPE_STRING,
+    bytes: TYPE_STRING,
+    bool: TYPE_BOOLEAN,
+    int: TYPE_INTEGER,
+    float: TYPE_FLOAT,
+}
+
+
+class BaseElasticSearch(BaseQueryRunner):
+    should_annotate_query = False
+    DEBUG_ENABLED = False
+
+    @classmethod
+    def configuration_schema(cls):
+        return {
+            "type": "object",
+            "properties": {
+                "server": {"type": "string", "title": "Base URL"},
+                "basic_auth_user": {"type": "string", "title": "Basic Auth User"},
+                "basic_auth_password": {
+                    "type": "string",
+                    "title": "Basic Auth Password",
+                },
+            },
+            "order": ["server", "basic_auth_user", "basic_auth_password"],
+            "secret": ["basic_auth_password"],
+            "required": ["server"],
+        }
+
+    @classmethod
+    def enabled(cls):
+        return False
+
+    def __init__(self, configuration):
+        super(BaseElasticSearch, self).__init__(configuration)
+        self.syntax = "json"
+
+        if self.DEBUG_ENABLED:
+            http_client.HTTPConnection.debuglevel = 1
+
+            # you need to initialize logging, otherwise you will not see anything from requests
+            logging.basicConfig()
+            logging.getLogger().setLevel(logging.DEBUG)
+            requests_log = logging.getLogger("requests.packages.urllib3")
+            requests_log.setLevel(logging.DEBUG)
+            requests_log.propagate = True
+
+            logger.setLevel(logging.DEBUG)
+
+        self.server_url = self.configuration["server"]
+        if self.server_url[-1] == "/":
+            self.server_url = self.server_url[:-1]
+
+        basic_auth_user = self.configuration.get("basic_auth_user", None)
+        basic_auth_password = self.configuration.get("basic_auth_password", None)
+        self.auth = None
+        if basic_auth_user and basic_auth_password:
+            self.auth = HTTPBasicAuth(basic_auth_user, basic_auth_password)
+
+    def _get_mappings(self, url):
+        mappings = {}
+        error = None
+        try:
+            r = requests.get(url, auth=self.auth)
+            r.raise_for_status()
+
+            mappings = r.json()
+        except requests.HTTPError as e:
+            logger.exception(e)
+            error = "Failed to execute query. Return Code: {0}   Reason: {1}".format(
+                r.status_code, r.text
+            )
+            mappings = None
+        except requests.exceptions.RequestException as e:
+            logger.exception(e)
+            error = "Connection refused"
+            mappings = None
+
+        return mappings, error
+
+    def _get_query_mappings(self, url):
+        mappings_data, error = self._get_mappings(url)
+        if error:
+            return mappings_data, error
+
+        mappings = {}
+        for index_name in mappings_data:
+            index_mappings = mappings_data[index_name]
+            for m in index_mappings.get("mappings", {}):
+                if "properties" not in index_mappings["mappings"][m]:
+                    continue
+                for property_name in index_mappings["mappings"][m]["properties"]:
+                    property_data = index_mappings["mappings"][m]["properties"][
+                        property_name
+                    ]
+                    if property_name not in mappings:
+                        property_type = property_data.get("type", None)
+                        if property_type:
+                            if property_type in ELASTICSEARCH_TYPES_MAPPING:
+                                mappings[property_name] = ELASTICSEARCH_TYPES_MAPPING[
+                                    property_type
+                                ]
+                            else:
+                                mappings[property_name] = TYPE_STRING
+                                # raise Exception("Unknown property type: {0}".format(property_type))
+
+        return mappings, error
+
+    def get_schema(self, *args, **kwargs):
+        def parse_doc(doc, path=None):
+            """Recursively parse a doc type dictionary
+            """
+            path = path or []
+            result = []
+            for field, description in doc["properties"].items():
+                if "properties" in description:
+                    result.extend(parse_doc(description, path + [field]))
+                else:
+                    result.append(".".join(path + [field]))
+            return result
+
+        schema = {}
+        url = "{0}/_mappings".format(self.server_url)
+        mappings, error = self._get_mappings(url)
+
+        if mappings:
+            # make a schema for each index
+            # the index contains a mappings dict with documents
+            # in a hierarchical format
+            for name, index in mappings.items():
+                columns = []
+                schema[name] = {"name": name}
+                for doc, items in index["mappings"].items():
+                    columns.extend(parse_doc(items))
+
+                # remove duplicates
+                # sort alphabetically
+                schema[name]["columns"] = sorted(set(columns))
+        return list(schema.values())
+
+    def _parse_results(
+        self, mappings, result_fields, raw_result, result_columns, result_rows
+    ):
+        def add_column_if_needed(
+            mappings, column_name, friendly_name, result_columns, result_columns_index
+        ):
+            if friendly_name not in result_columns_index:
+                result_columns.append(
+                    {
+                        "name": friendly_name,
+                        "friendly_name": friendly_name,
+                        "type": mappings.get(column_name, "string"),
+                    }
+                )
+                result_columns_index[friendly_name] = result_columns[-1]
+
+        def get_row(rows, row):
+            if row is None:
+                row = {}
+                rows.append(row)
+            return row
+
+        def collect_value(mappings, row, key, value, type):
+            if result_fields and key not in result_fields_index:
+                return
+
+            mappings[key] = type
+            add_column_if_needed(
+                mappings, key, key, result_columns, result_columns_index
+            )
+            row[key] = value
+
+        def collect_aggregations(
+            mappings, rows, parent_key, data, row, result_columns, result_columns_index
+        ):
+            if isinstance(data, dict):
+                for key, value in data.items():
+                    val = collect_aggregations(
+                        mappings,
+                        rows,
+                        parent_key if key == "buckets" else key,
+                        value,
+                        row,
+                        result_columns,
+                        result_columns_index,
+                    )
+                    if val:
+                        row = get_row(rows, row)
+                        collect_value(mappings, row, key, val, "long")
+
+                for data_key in ["value", "doc_count"]:
+                    if data_key not in data:
+                        continue
+                    if "key" in data and len(list(data.keys())) == 2:
+                        key_is_string = "key_as_string" in data
+                        collect_value(
+                            mappings,
+                            row,
+                            data["key"] if not key_is_string else data["key_as_string"],
+                            data[data_key],
+                            "long" if not key_is_string else "string",
+                        )
+                    else:
+                        return data[data_key]
+
+            elif isinstance(data, list):
+                for value in data:
+                    result_row = get_row(rows, row)
+                    collect_aggregations(
+                        mappings,
+                        rows,
+                        parent_key,
+                        value,
+                        result_row,
+                        result_columns,
+                        result_columns_index,
+                    )
+                    if "doc_count" in value:
+                        collect_value(
+                            mappings,
+                            result_row,
+                            "doc_count",
+                            value["doc_count"],
+                            "integer",
+                        )
+                    if "key" in value:
+                        if "key_as_string" in value:
+                            collect_value(
+                                mappings,
+                                result_row,
+                                parent_key,
+                                value["key_as_string"],
+                                "string",
+                            )
+                        else:
+                            collect_value(
+                                mappings, result_row, parent_key, value["key"], "string"
+                            )
+
+            return None
+
+        result_columns_index = {c["name"]: c for c in result_columns}
+
+        result_fields_index = {}
+        if result_fields:
+            for r in result_fields:
+                result_fields_index[r] = None
+
+        if "error" in raw_result:
+            error = raw_result["error"]
+            if len(error) > 10240:
+                error = error[:10240] + "... continues"
+
+            raise Exception(error)
+        elif "aggregations" in raw_result:
+            if result_fields:
+                for field in result_fields:
+                    add_column_if_needed(
+                        mappings, field, field, result_columns, result_columns_index
+                    )
+
+            for key, data in raw_result["aggregations"].items():
+                collect_aggregations(
+                    mappings,
+                    result_rows,
+                    key,
+                    data,
+                    None,
+                    result_columns,
+                    result_columns_index,
+                )
+
+            logger.debug("result_rows %s", str(result_rows))
+            logger.debug("result_columns %s", str(result_columns))
+        elif "hits" in raw_result and "hits" in raw_result["hits"]:
+            if result_fields:
+                for field in result_fields:
+                    add_column_if_needed(
+                        mappings, field, field, result_columns, result_columns_index
+                    )
+
+            for h in raw_result["hits"]["hits"]:
+                row = {}
+
+                column_name = "_source" if "_source" in h else "fields"
+                for column in h[column_name]:
+                    if result_fields and column not in result_fields_index:
+                        continue
+
+                    add_column_if_needed(
+                        mappings, column, column, result_columns, result_columns_index
+                    )
+
+                    value = h[column_name][column]
+                    row[column] = (
+                        value[0]
+                        if isinstance(value, list) and len(value) == 1
+                        else value
+                    )
+
+                result_rows.append(row)
+        else:
+            raise Exception(
+                "Redash failed to parse the results it got from Elasticsearch."
+            )
+
+    def test_connection(self):
+        try:
+            r = requests.get(
+                "{0}/_cluster/health".format(self.server_url), auth=self.auth
+            )
+            r.raise_for_status()
+        except requests.HTTPError as e:
+            logger.exception(e)
+            raise Exception(
+                "Failed to execute query. Return Code: {0}   Reason: {1}".format(
+                    r.status_code, r.text
+                )
+            )
+        except requests.exceptions.RequestException as e:
+            logger.exception(e)
+            raise Exception("Connection refused")
+
+
+class Kibana(BaseElasticSearch):
+    @classmethod
+    def enabled(cls):
+        return True
+
+    def _execute_simple_query(
+        self, url, auth, _from, mappings, result_fields, result_columns, result_rows
+    ):
+        url += "&from={0}".format(_from)
+        r = requests.get(url, auth=self.auth)
+        r.raise_for_status()
+
+        raw_result = r.json()
+
+        self._parse_results(
+            mappings, result_fields, raw_result, result_columns, result_rows
+        )
+
+        total = raw_result["hits"]["total"]
+        result_size = len(raw_result["hits"]["hits"])
+        logger.debug("Result Size: {0}  Total: {1}".format(result_size, total))
+
+        return raw_result["hits"]["total"]
+
+    def run_query(self, query, user):
+        try:
+            error = None
+
+            logger.debug(query)
+            query_params = json_loads(query)
+
+            index_name = query_params["index"]
+            query_data = query_params["query"]
+            size = int(query_params.get("size", 500))
+            limit = int(query_params.get("limit", 500))
+            result_fields = query_params.get("fields", None)
+            sort = query_params.get("sort", None)
+
+            if not self.server_url:
+                error = "Missing configuration key 'server'"
+                return None, error
+
+            url = "{0}/{1}/_search?".format(self.server_url, index_name)
+            mapping_url = "{0}/{1}/_mapping".format(self.server_url, index_name)
+
+            mappings, error = self._get_query_mappings(mapping_url)
+            if error:
+                return None, error
+
+            if sort:
+                url += "&sort={0}".format(urllib.parse.quote_plus(sort))
+
+            url += "&q={0}".format(urllib.parse.quote_plus(query_data))
+
+            logger.debug("Using URL: {0}".format(url))
+            logger.debug("Using Query: {0}".format(query_data))
+
+            result_columns = []
+            result_rows = []
+            if isinstance(query_data, str):
+                _from = 0
+                while True:
+                    query_size = size if limit >= (_from + size) else (limit - _from)
+                    total = self._execute_simple_query(
+                        url + "&size={0}".format(query_size),
+                        self.auth,
+                        _from,
+                        mappings,
+                        result_fields,
+                        result_columns,
+                        result_rows,
+                    )
+                    _from += size
+                    if _from >= limit:
+                        break
+            else:
+                # TODO: Handle complete ElasticSearch queries (JSON based sent over HTTP POST)
+                raise Exception("Advanced queries are not supported")
+
+            json_data = json_dumps({"columns": result_columns, "rows": result_rows})
+        except requests.HTTPError as e:
+            logger.exception(e)
+            error = "Failed to execute query. Return Code: {0}   Reason: {1}".format(
+                r.status_code, r.text
+            )
+            json_data = None
+        except requests.exceptions.RequestException as e:
+            logger.exception(e)
+            error = "Connection refused"
+            json_data = None
+
+        return json_data, error
+
+
+class ElasticSearch(BaseElasticSearch):
+    @classmethod
+    def enabled(cls):
+        return True
+
+    @classmethod
+    def name(cls):
+        return "Elasticsearch"
+
+    def run_query(self, query, user):
+        try:
+            error = None
+
+            logger.debug(query)
+            query_dict = json_loads(query)
+
+            index_name = query_dict.pop("index", "")
+            result_fields = query_dict.pop("result_fields", None)
+
+            if not self.server_url:
+                error = "Missing configuration key 'server'"
+                return None, error
+
+            url = "{0}/{1}/_search".format(self.server_url, index_name)
+            mapping_url = "{0}/{1}/_mapping".format(self.server_url, index_name)
+
+            mappings, error = self._get_query_mappings(mapping_url)
+            if error:
+                return None, error
+
+            logger.debug("Using URL: %s", url)
+            logger.debug("Using query: %s", query_dict)
+            r = requests.get(url, json=query_dict, auth=self.auth)
+            r.raise_for_status()
+            logger.debug("Result: %s", r.json())
+
+            result_columns = []
+            result_rows = []
+            self._parse_results(
+                mappings, result_fields, r.json(), result_columns, result_rows
+            )
+
+            json_data = json_dumps({"columns": result_columns, "rows": result_rows})
+        except (KeyboardInterrupt, JobTimeoutException):
+            logger.exception(e)
+            raise
+        except requests.HTTPError as e:
+            logger.exception(e)
+            error = "Failed to execute query. Return Code: {0}   Reason: {1}".format(
+                r.status_code, r.text
+            )
+            json_data = None
+        except requests.exceptions.RequestException as e:
+            logger.exception(e)
+            error = "Connection refused"
+            json_data = None
+
+        return json_data, error
+
+
+register(Kibana)
+register(ElasticSearch)

lesscode_flask-0.0.31/redash/utils/__init__.py

@@ -0,0 +1,71 @@
+import binascii
+
+import datetime
+import decimal
+
+import json
+
+import uuid
+
+from sqlalchemy.orm.query import Query
+
+
+class JSONEncoder(json.JSONEncoder):
+    """Adapter for `json.dumps`."""
+
+    def __init__(self, **kwargs):
+        from redash.query_runner import query_runners
+
+        self.encoders = [r.custom_json_encoder for r in query_runners.values() if hasattr(r, "custom_json_encoder")]
+        super().__init__(**kwargs)
+
+    def default(self, o):
+        for encoder in self.encoders:
+            result = encoder(self, o)
+            if result:
+                return result
+        if isinstance(o, Query):
+            result = list(o)
+        elif isinstance(o, decimal.Decimal):
+            result = float(o)
+        elif isinstance(o, (datetime.timedelta, uuid.UUID)):
+            result = str(o)
+        # See "Date Time String Format" in the ECMA-262 specification.
+        elif isinstance(o, datetime.datetime):
+            result = o.isoformat()
+            if o.microsecond:
+                result = result[:23] + result[26:]
+            if result.endswith("+00:00"):
+                result = result[:-6] + "Z"
+        elif isinstance(o, datetime.date):
+            result = o.isoformat()
+        elif isinstance(o, datetime.time):
+            if o.utcoffset() is not None:
+                raise ValueError("JSON can't represent timezone-aware times.")
+            result = o.isoformat()
+            if o.microsecond:
+                result = result[:12]
+        elif isinstance(o, memoryview):
+            result = binascii.hexlify(o).decode()
+        elif isinstance(o, bytes):
+            result = binascii.hexlify(o).decode()
+        else:
+            result = super().default(o)
+        return result
+
+
+def json_loads(data, *args, **kwargs):
+    """A custom JSON loading function which passes all parameters to the
+    json.loads function."""
+    return json.loads(data, *args, **kwargs)
+
+
+def json_dumps(data, *args, **kwargs):
+    """A custom JSON dumping function which passes all parameters to the
+    json.dumps function."""
+    kwargs.setdefault("cls", JSONEncoder)
+    kwargs.setdefault("ensure_ascii", False)
+    # Float value nan or inf in Python should be render to None or null in json.
+    # Using allow_nan = True will make Python render nan as NaN, leading to parse error in front-end
+    kwargs.setdefault("allow_nan", False)
+    return json.dumps(data, *args, **kwargs)

lesscode_flask-0.0.27/lesscode_flask/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.0.27'