1

.gitignore

+/venv/

Dockerfile

+FROM python:3.8
+WORKDIR /
+
+COPY requirements.txt ./
+RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+COPY . .
+
+CMD ["gunicorn", "start:app", "-c", "./gunicorn.conf.py"]
\ No newline at end of file

app/__init__.py

+import os
+
+from flask import Flask
+
+
+def create_app(test_config=None):
+    # create and configure the app
+    app = Flask(__name__, instance_relative_config=True)
+    app.config.from_mapping(
+        SECRET_KEY='dev',
+        DATABASE=os.path.join(app.instance_path, 'apps.sqlite'),
+    )
+
+    from app.controller import search
+    from app.controller import importdata
+    from app.controller import auth
+    app.register_blueprint(auth.bp)
+    app.register_blueprint(importdata.bp)
+    app.register_blueprint(search.bp)
+
+    if test_config is None:
+        # load the instance config, if it exists, when not testing
+        app.config.from_pyfile('config.py', silent=True)
+    else:
+        # load the test config if passed in
+        app.config.from_mapping(test_config)
+
+    # ensure the instance folder exists
+    try:
+        os.makedirs(app.instance_path)
+    except OSError:
+        pass
+    return app

app/controller/auth.py

+from flask import (
+    Blueprint, flash, g, redirect, render_template, request, session, url_for
+)
+
+bp = Blueprint('auth', __name__, url_prefix='/auth')
+
+
+@bp.route('/register', methods=('GET', 'POST'))
+def register():
+    return "注册视图...."
\ No newline at end of file

app/controller/search.py

+import re
+from flask import Blueprint, request, json
+from pyecharts import options as opts
+from pyecharts.charts import Graph as pg
+from app.model.base import dbconn, graph
+
+bp = Blueprint('search', __name__, url_prefix='/search')
+
+keyword = []
+keyword_clinical = {}
+
+sql_str = 'SELECT clinical, keyword FROM keyword_clinical'
+
+rows = dbconn.query(
+    sql=sql_str
+)
+
+for val_keyword in rows:
+    keyword.append(val_keyword['keyword'])
+    keyword_clinical[val_keyword['keyword']] = val_keyword['clinical']
+
+
+@bp.route('/illness_search', methods=['POST', 'GET'])
+def illness_search():
+    if request.method == 'POST':
+        req = request.get_json()
+
+        vocab_pattern = '|'.join(keyword)
+
+        vocab_data = re.findall(vocab_pattern, req['search'])
+
+        # search_data = search_keyword(vocab_data)
+        search_data = []
+        for val1 in vocab_data:
+            search_data.append(keyword_clinical[val1])
+
+        # strData = jieba.cut(data['search_str'], cut_all=False)
+
+        # graph_sql = "match (n:`疾病（三）`) "
+        #
+        # for search_str in search_data:
+        #     if search_str == '':
+        #         continue
+        #     graph_sql += " with n match (n:`疾病（三）`)-[*1]->(a) where a.name='" + search_str + "' "
+        #
+        # graph_sql += " return n"
+        #
+        # graph_data = graph.run(graph_sql).data()
+
+        illness_data = {}
+        for search_str in search_data:
+            if search_str == '':
+                continue
+            graph_sql = "match (n:`疾病（三）`)-[*1]->(a:`病症`) where a.name='" + search_str + "' return n"
+
+            graph_data = graph.run(graph_sql).data()
+
+            for val2 in graph_data:
+                if val2['n']['name'] in illness_data.keys():
+                    illness_data[val2['n']['name']]['num'] += 1
+                else:
+                    illness_data[val2['n']['name']] = {'num': 1, 'name': val2['n']['name']}
+
+        if len(illness_data) == 0:
+            return ''
+
+        result = []
+        list_illness_data = list(illness_data)
+        for key1 in list_illness_data:
+
+            graph_sql2 = "match (a:`疾病（三）`)-[]->(m:`治疗方案`)-[]->(n:`药品`) where a.name='" + key1 + "' return m,n"
+
+            graph_data2 = graph.run(graph_sql2).data()
+
+            graph_sql3 = "match (a:`疾病（三）`)-[]->(m:`治疗方案`) where a.name='" + key1 + "' return m,n"
+
+            graph_data3 = graph.run(graph_sql3).data()
+
+            medicinal = {}
+            for val2 in graph_data2:
+                if val2['m']['name'] in medicinal.keys():
+                    medicinal[val2['m']['name']].append(val2['n']['name'])
+                else:
+                    medicinal[val2['m']['name']] = [val2['n']['name']]
+
+            illness_data[key1]['treatment'] = medicinal
+
+            result.append(illness_data[key1])
+
+        # print(result)
+
+        return json.dumps(result)
+
+
+def testaaa():
+    illnessDict = {}  # 疾病
+    symptomsDict = {}  # 病症
+    shipsData = {}  # 三元组
+
+    graph_sql = "match (n:`疾病（三）`)-[*1]->(a:`病症`) where a.name='" + search_str + "' return n"
+
+    graph_data = graph.run(graph_sql).data()
+
+    while graph_data.forward():
+        for relation in graph_data.current['p']:
+            print(list(relation.types()))
+            illness_node = relation.start_node
+            symptoms_node = relation.end_node
+            relation_type = list(relation.types())[0]
+            illness_node_label = str(illness_node.labels).strip(":")
+            symptoms_node_label = str(symptoms_node.labels).strip(":")
+
+            # 存储三元组关系
+            if illness_node['id'] in shipsData.keys():
+                target_dict = shipsData.get(illness_node['id'])
+                target_dict.setdefault(symptoms_node['id'], relation_type)
+            else:
+                target_dict = {symptoms_node['id']: relation_type}
+                shipsData[illness_node['id']] = target_dict
+            # 存储节点
+            if ("`疾病（三）`" == illness_node_label) and (illness_node['id'] not in illnessDict.keys()):
+                illnessDict[illness_node['id']] = illness_node['name']
+
+            if ("病症" == symptoms_node_label) and (symptoms_node['id'] not in symptomsDict.keys()):
+                symptomsDict[symptoms_node['id']] = symptoms_node['name']
+
+    json_list = []
+    for illness_key, value in shipsData.items():
+        for symptoms_key, rel_type in value.items():
+            result_dict = {
+                'illness': illnessDict[illness_key],
+                'rel_type': rel_type,
+                'symptoms': symptomsDict[symptoms_key]
+            }
+            json_list.append(result_dict)
+
+    print(len(json_list))
+    for i in range(len(json_list)):
+        print("{}-[{}]->{}".format(json_list[i]['illness'], json_list[i]['rel_type'], json_list[i]['symptoms']))
+
+    return json_list
+
+    data_dict = set()
+    nodes = []
+    links = []
+    for i in range(len(json_list)):
+        if json_list[i]['illness'] not in data_dict:
+            data_dict.add(json_list[i]['illness'])
+            nodes.append({'name': json_list[i]['illness'], "symbolSize": 10, 'draggable': 'true'})
+        if json_list[i]['symptoms'] not in data_dict:
+            data_dict.add(json_list[i]['symptoms'])
+            nodes.append({'name': json_list[i]['symptoms'], "symbolSize": 10, 'draggable': 'true'})
+        links.append({'source': json_list[i]['illness'], 'target': json_list[i]['symptoms']})
+
+    pg_graph = pg(init_opts=opts.InitOpts(width='1000px', height='800px'))
+    pg_graph.add("", nodes, links, repulsion=8000, edge_symbol=['', 'arrow'])
+    pg_graph.set_global_opts(title_opts=opts.TitleOpts(title="病症对应的疾病"))
+
+    # print('/'.join(strData)+"")
+
+    # sql='SELECT d.id, d.drug_name,a.res FROM drug as d left join api as a on d.drug_name = a.param where d.id > 943'
+    # drug = mysqlconn.query(
+    #     sql='SELECT d.id, d.disease_name FROM disease as d where d.id > 0'
+    # )
+    # print(drug)
+    # return render_template('index.html')
+    return pg_graph.render_notebook()
+    # return json.dumps(list(strData))

app/model/base.py

+from lib.libmysql import MYSQL, connect_db
+from py2neo import Graph, Node, Relationship, NodeMatcher
+
+dbconn = MYSQL(
+    dbhost='39.96.85.45',
+    dbport=3307,
+    dbuser='root',
+    dbpwd='abc123456',
+    dbname='Illness',
+    dbcharset='utf8'
+)
+
+dbconn2 = MYSQL(
+    dbhost='rm-2zenl1z0v6209a4jrbo.mysql.rds.aliyuncs.com',
+    dbport=3306,
+    dbuser='root_medical',
+    dbpwd='dbc_medical888888!',
+    dbname='dbc_medical_record',
+    dbcharset='utf8'
+)
+
+
+graph = Graph("", auth=("neo4j", "11111111"))

gunicorn.conf.py

+workers = 5    # 定义同时开启的处理请求的进程数量，根据网站流量适当调整
+worker_class = "gevent"   # 采用gevent库，支持异步处理请求，提高吞吐量
+bind = "0.0.0.0:5080"
\ No newline at end of file

lib/PathDispatcher.py

+import cgi
+
+
+def notfound_404(environ, start_response):
+    start_response('404 Not Found', [('Content-type', 'text/plain')])
+    return [b'Not Found']
+
+
+class PathDispatcher:
+    def __init__(self):
+        self.pathmap = {}
+
+    def __call__(self, environ, start_response):
+        path = environ['PATH_INFO']
+        params = cgi.FieldStorage(environ['wsgi.input'], environ=environ)
+        method = environ['REQUEST_METHOD'].lower()
+        environ['params'] = {key: params.getvalue(key) for key in params}
+        handler = self.pathmap.get((method, path), notfound_404)
+        return handler(environ, start_response)
+
+    def register(self, method, path, function):
+        self.pathmap[method.lower(), path] = function
+        return function

lib/libmysql.py

+# encoding: utf-8
+from pymysql import (connect, cursors, err)
+
+
+def connect_db(mysqldb_conn):
+    # msyql dababase connection info
+    dbconn = MYSQL(
+        dbhost=mysqldb_conn.get('host'),
+        dbport=mysqldb_conn.get('port') or 3306,
+        dbuser=mysqldb_conn.get('user'),
+        dbpwd=mysqldb_conn.get('password'),
+        dbname=mysqldb_conn.get('db'),
+        dbcharset=mysqldb_conn.get('charset'))
+    # dbconn.
+    return dbconn
+
+
+def connect_ssdc(mysqldb_conn):
+    """Connect to the database return SSDictCursor dbsession"""
+    connection = connect(
+        host=mysqldb_conn.get('host'),
+        port=int(mysqldb_conn.get('port')) or 3306,
+        user=mysqldb_conn.get('user'),
+        password=mysqldb_conn.get('password'),
+        db=mysqldb_conn.get('db'),
+        charset=mysqldb_conn.get('charset'),
+        cursorclass=cursors.SSDictCursor)
+    return connection
+
+
+class MYSQL:
+    """A Friendly pymysql Class, Provide CRUD functionality"""
+
+    def __init__(self, dbhost, dbuser, dbpwd, dbname, dbcharset='utf-8', dbport=3306):
+        self.dbhost = dbhost
+        self.dbport = dbport
+        self.dbuser = dbuser
+        self.dbpwd = dbpwd
+        self.dbname = dbname
+        self.dbcharset = dbcharset
+        self.connection = self.session()
+
+    def session(self):
+        """Connect to the database return dbsession"""
+        connection = connect(
+            host=self.dbhost,
+            port=self.dbport,
+            user=self.dbuser,
+            password=self.dbpwd,
+            db=self.dbname,
+            charset=self.dbcharset,
+            cursorclass=cursors.DictCursor)
+        return connection
+
+    def insert(self, table, data):
+        """mysql insert() function"""
+
+        with self.connection.cursor() as cursor:
+            params = self.join_field_value(data)
+
+            sql = "INSERT IGNORE INTO {table} SET {params}".format(
+                table=table, params=params)
+
+            cursor.execute(sql, tuple(data.values()))
+            last_id = self.connection.insert_id()
+
+            self.connection.commit()
+            return last_id
+
+    def delete(self, table, condition=None, limit=None):
+        """
+        mysql delete() function
+        sql.PreparedStatement method
+        """
+        with self.connection.cursor() as cursor:
+
+            prepared = []
+
+            if not condition:
+                where = '1'
+            elif isinstance(condition, dict):
+                where = self.join_field_value(condition, ' AND ')
+                prepared.extend(condition.values())
+            else:
+                where = condition
+
+            limits = "LIMIT {limit}".format(limit=limit) if limit else ""
+
+            sql = "DELETE FROM {table} WHERE {where} {limits}".format(
+                table=table, where=where, limits=limits)
+
+            if not prepared:
+                result = cursor.execute(sql)
+            else:
+                result = cursor.execute(sql, tuple(prepared))
+
+            self.connection.commit()
+            return result
+
+    def update(self, table, data, condition=None):
+        """
+        mysql update() function
+        Use sql.PreparedStatement method
+        """
+        with self.connection.cursor() as cursor:
+
+            prepared = []
+            params = self.join_field_value(data)
+            prepared.extend(data.values())
+
+            if not condition:
+                where = '1'
+            elif isinstance(condition, dict):
+                where = self.join_field_value(condition, ' AND ')
+                prepared.extend(condition.values())
+            else:
+                where = condition
+
+            sql = "UPDATE IGNORE {table} SET {params} WHERE {where}".format(
+                table=table, params=params, where=where)
+
+            # check PreparedStatement
+            if not prepared:
+                result = cursor.execute(sql)
+            else:
+                result = cursor.execute(sql, tuple(prepared))
+
+            self.connection.commit()
+            return result
+
+    def count(self, table, condition=None):
+        """
+        count database record
+        Use sql.PreparedStatement method
+        """
+        with self.connection.cursor() as cursor:
+
+            prepared = []
+
+            if not condition:
+                where = '1'
+            elif isinstance(condition, dict):
+                where = self.join_field_value(condition, ' AND ')
+                prepared.extend(condition.values())
+            else:
+                where = condition
+
+            sql = "SELECT COUNT(*) as cnt FROM {table} WHERE {where}".format(
+                table=table, where=where)
+
+            if not prepared:
+                cursor.execute(sql)
+            else:
+                cursor.execute(sql, tuple(prepared))
+
+            self.connection.commit()
+            return cursor.fetchone().get('cnt')
+
+    def fetch_rows(self, table, fields=None, condition=None, order=None, limit=None, fetchone=False):
+        """
+        mysql select() function
+        Use sql.PreparedStatement method
+        """
+        with self.connection.cursor() as cursor:
+
+            prepared = []
+
+            if not fields:
+                fields = '*'
+            elif isinstance(fields, tuple) or isinstance(fields, list):
+                fields = '`{0}`'.format('`, `'.join(fields))
+            else:
+                fields = fields
+
+            if not condition:
+                where = '1'
+            elif isinstance(condition, dict):
+                where = self.join_field_value(condition, ' AND ')
+                prepared.extend(condition.values())
+            else:
+                where = condition
+
+            if not order:
+                orderby = ''
+            else:
+                orderby = 'ORDER BY {order}'.format(order=order)
+
+            limits = "LIMIT {limit}".format(limit=limit) if limit else ""
+
+            sql = "SELECT {fields} FROM {table} WHERE {where} {orderby} {limits}".format(
+                fields=fields, table=table, where=where, orderby=orderby, limits=limits)
+
+            # print(sql)
+            
+            if not prepared:
+                cursor.execute(sql)
+            else:
+                cursor.execute(sql, tuple(prepared))
+
+            self.connection.commit()
+            return cursor.fetchone() if fetchone else cursor.fetchall()
+
+    def query(self, sql, fetchone=False, execute=False):
+        print(sql)
+        """execute custom sql query"""
+        with self.connection.cursor() as cursor:
+            cursor.execute(sql)
+            self.connection.commit()
+
+            if execute:
+                return
+
+            return cursor.fetchone() if fetchone else cursor.fetchall()
+
+    def join_field_value(self, data, glue=', '):
+        sql = comma = ''
+        for key in data.keys():
+            sql += "{}`{}` = %s".format(comma, key)
+            comma = glue
+        return sql
+
+    def close(self):
+        if getattr(self, 'connection', 0):
+            return self.connection.close()
+
+    def __del__(self):
+        """close mysql database connection"""
+        self.close()

lib/mod_config.py

+#!/usr/bin/env python
+# encoding: utf-8
+import configparser
+import os
+import socket
+
+conf_file = '/conf/prod.conf'
+# conf_file = '/conf/dev.conf'
+
+def get_host_ip():
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(('8.8.8.8', 80))
+        ip = s.getsockname()[0]
+    finally:
+        s.close()
+    return ip
+
+
+IP = get_host_ip()
+print(IP)
+
+# if IP == '172.19.0.11':
+#     conf_file = '/conf/dev.conf'
+# elif IP == '10.0.0.136':
+#     conf_file = '/conf/dev.conf'
+# else:
+#     print('prod')
+#     exit()
+
+# conf_file = '/conf/prod.conf'
+
+# 获取config配置文件
+def getConfigOne(section, key):
+    config = configparser.ConfigParser()
+    path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    config.read(path + conf_file)
+    return config.get(section, key)
+
+
+# 获取config配置文件
+def getConfig():
+    config = configparser.ConfigParser()
+    path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    config.read(path + conf_file)
+    return config

requirements.txt

+beautifulsoup4==4.12.3
+clickhouse_driver==0.2.7
+Flask==3.0.3
+py2neo==2021.2.3
+pyecharts==2.0.5
+PyMySQL==1.1.0
+Requests==2.31.0

start.py

+from app import create_app
+
+app = create_app()
+
+if __name__ == '__main__':
+    app.run()