Skip to content

M
mancheng
Commit dcddd7c9 by root
Options

招商驾驶舱

parents
Showing with 15691 additions and 0 deletions
README.md 0 → 100644
# 太原招商图谱项目
# 如果找不到models,就在启动文件引入
# from apps.models import *
# 批量删除指定模式的redis缓存
# redis --scan --pattern "tendency*" | xargs -L 2000 redis del
# 更新数据后招商雷达界面数据更新：删除redis缓存
# 路径：/usr/local/redis/bin 命令：./redis-cli -a password keys "radar32*" | xargs ./redis-cli -a password del 有效
~~**_虚拟环境py37 /root/py37
代码位置 /root/code/ty
es /root/code/ruiqi_wenda ,使用非root用户启用，用户名tyuser
neo4j /root/code/neo4j ,密码:century-english-almanac-havana-golf-9040
mysql 密码:Mypwdty2020!
redis_**~~
```
es共两个索引
ty_com2product、ty_enterprise
```
redis 备份脚本 /usr/local/redis/redis_rdb_bak_daily.sh
mysql 备份脚本 /root/code/mysql_dump_script.sh
es 备份脚本 /home/tyuser/elasticsearch/backup/output_es.sh
通过定时器crontab定时备份
\ No newline at end of file
apps/__init__.py 0 → 100644
import os
import redis
import logging
from flask import Flask
from config import config_map
from flask_sqlalchemy import SQLAlchemy
from flask_session import Session
from flask_wtf import CSRFProtect
from flask_cors import CORS
from flask_mail import Mail
from logging.handlers import RotatingFileHandler
from apps.utils.commons import RegexConverter
# from apps.util import RegexConverter
from flask_qiniustorage import Qiniu
db = SQLAlchemy() # 创建数据库连接
qiniu_store = Qiniu() # 创建七牛云连接
redis_store = None # 创建变量避免导入错误，在函数中进行初始化
# 配置日志信息
# 创建日志记录器，指明日志保存的路径、每个日志文件的最大大小、保存的日志文件个数上限
file_log_handler = RotatingFileHandler("../logs/log", maxBytes=1024 * 1024 * 100, backupCount=10)
stream_log_handler = logging.StreamHandler()
# 创建日志记录的格式 日志等级 输入日志信息的文件名 行数 日志信息
formatter = logging.Formatter('%(levelname)s %(filename)s:%(lineno)d %(message)s')
# 为刚创建的日志记录器设置日志记录格式
file_log_handler.setFormatter(formatter)
# 为全局的日志工具对象（flask app使用的）添加日志记录器
logging.getLogger().addHandler(file_log_handler)
# 为全局的日志工具对象（flask app使用的）添加控制台显示记录器
logging.getLogger().addHandler(stream_log_handler)
# 设置日志的记录等级
# logging.basicConfig(level=logging.DEBUG) # 调试debug级，会受flask的debug=True影响，强制忽略设置的等级
logging.basicConfig(level=logging.INFO) # 调试debug级，会受flask的debug=True影响，强制忽略设置的等级
# 跨域支持
def after_request(resp):
resp.headers['Access-Control-Allow-Origin'] = '*'
resp.headers['Access-Control-Allow-Credentials'] = 'TRUE'
resp.headers[
'Access-Control-Allow-Headers'] = 'x-requested-with,content-type,token' # 允许的请求header
resp.headers['Access-Control-Allow-Methods'] = 'GET,POST,OPTIONS'
return resp
# 允许的请求header示例
# 'Content-Type,Authorization,X-Requested-With,token,application/octet-stream'
# x-requested-with,content-type
# "Accept,Authorization,Cache-Control,Content-Type,DNT,If-Modified-Since,Keep-Alive,Origin,User-Agent,X-Requested-With"
def creat_app(config_name):
'''
:param config_name: str 配置模式的名称('develop', 'product')
:return: object flask的app对象
'''
app = Flask(__name__)
app.after_request(after_request)
config_class = config_map.get(config_name)
app.config.from_object(config_class)
# 绑定SQLAlchemy的app对象
db.init_app(app)
# 七牛
qiniu_store.init_app(app)
# 初始化redis工具，创建Redis连接对象用于缓存
global redis_store
redis_store = redis.StrictRedis(host=config_class.REDIS_HOST, port=config_class.REDIS_PORT,password=config_class.REDIS_PASS)
# cors跨域插件,是否允许发送cookies
# CORS(app, supports_credentials=True)
# CORS(app, resources={r"/.*": {"origins": ["http://bigxigua.net","http://localhost:8006"]}})
CORS(app, resources=r'/*')
# 邮箱
Mail(app)
# 利用flask_session扩展将session数据保存到redis中
Session(app)
# 为flask补充CSRF防护
# CSRFProtect(app)
# 为flask添加自定义的转换器
app.url_map.converters['re'] = RegexConverter
# 注册蓝图，推迟导入，防止循环嵌套
# from apps.user_pc import api_user
# from apps.atlas import api_atlas
# from apps.radar import api_radar
# from apps.attract import api_att
from apps.view_attract import api_attract
# from apps.view_360 import api_portraits
# from apps.view_choose_address import api_address
# from apps.manage import api_power
# from apps.inves_manage import api_manage
# from apps.view_mobile import api_mobile
# app.register_blueprint(api_user, url_prefix='/api/user')
# app.register_blueprint(api_radar, url_prefix='/api/radar')
# app.register_blueprint(api_atlas, url_prefix='/api/atlas')
# app.register_blueprint(api_att, url_prefix='/api/att')
#
# app.register_blueprint(api_attract, url_prefix='/api/attract/industry')
# app.register_blueprint(api_portraits, url_prefix="/api/portraits/industry")
# app.register_blueprint(api_address, url_prefix="/api/address/industry")
# app.register_blueprint(api_power, url_prefix="/api/power")
# app.register_blueprint(api_manage, url_prefix="/api/manage")
# app.register_blueprint(api_mobile, url_prefix="/api/mobile")
return app
apps/atlas/__init__.py 0 → 100644
from flask import Blueprint
# 创建蓝图对象
api_atlas = Blueprint("api_atlas", __name__)
from . import view #
from . import view_detail # 产业发展图谱下详情页
from . import view_es # 政策
from . import view_graph # 产业发展图谱业图谱
from . import view_es_con # 企业详情页的产业链和地图散点
'''产业发展图谱'''
apps/atlas/view.py 0 → 100644
from flask import current_app, request, jsonify
from apps.atlas import api_atlas
from sqlalchemy import extract, or_, and_
from sqlalchemy.sql import func
from apps.models import *
from apps.util import login_required, verify_token
from apps.utils.response_code import RET
from datetime import datetime, timedelta
# 行业分类自定义层级信息全部获取(2020-11-3)
@api_atlas.route('/get_fields', methods=['GET'])
@login_required
def get_fields():
'''获取左侧导航信息一览，两级导航'''
try:
# 获取一级行业
fields = Industry.query.filter_by(fid=0, statu=1).all()
print(fields)
data = []
for field in fields:
df = {"id": field.nid,
"cate": "1",
"label": field.name,
"children": []}
childs = Industry.query.filter_by(fid=field.nid, statu=1).all()
for child in childs:
df["children"].append({"id": child.nid,
"label": child.name,
"cate": "2"})
data.append(df)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", navleftdata=data)
# 二级行业收藏状态获取
@api_atlas.route('/inducollect/<id>', methods=['GET'])
@login_required
def inducollect(id):
'''获取当前用户对二级行业的收藏状态'''
token = request.headers["token"]
user = verify_token(token)
user_id = user.id # 用户id
try:
user = User.query.get(user_id) # 获取关注列表
industrys = user.industry
if industrys:
indu_ids = [indu.id for indu in user.industry]
else:
indu_ids = []
if int(id) in indu_ids:
return jsonify(code=RET.OK, msg="查询成功", collect="1")
else:
return jsonify(code=RET.OK, msg="查询成功", collect="2")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 行业业收藏与取消
@api_atlas.route('/industry/collect', methods=['POST'])
@login_required
def indu_collect():
'''企业收藏与状态取消'''
token = request.headers["token"]
user = verify_token(token)
user_id = user.id # 用户id
req_dict = request.get_json()
_id = req_dict.get("id") # 二级行业id
collect = req_dict.get("collect") # 关注状态(1是，2否)
# 校验参数完整性
if not all([_id, collect]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if collect == "2": # 未关注，我要关注
user = User.query.get(user_id)
indu = Industry.query.filter_by(nid=_id).first()
user.industry.append(indu)
db.session.commit()
return jsonify(code=RET.OK, msg="收藏成功", collect="1")
elif collect == "1": # 已关注，我要取关
user = User.query.get(user_id)
indu = Industry.query.filter_by(nid=_id).first()
user.industry.remove(indu)
db.session.commit()
return jsonify(code=RET.OK, msg="取消收藏", collect="2")
else:
return jsonify(code=RET.DATAERR, msg="参数异常")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 太原市企业条件选择导航(类型，资质，上市，融资，时间，注册资本，区县选择)
@api_atlas.route('/industry/field', methods=['GET'])
# @login_required
def field():
'''太原市企业条件选择导航获取'''
try:
property = Propertyty.query.filter_by(statu=1)
typy = property.filter_by(sid=1, statu=1).all()
qualificat = property.filter_by(sid=2, statu=1).all()
quoted = property.filter_by(sid=3, statu=1).all()
financ = property.filter_by(sid=4, statu=1).all()
# options: [{ value: "选项1", label: "无数据" },{ value: "选项2", label: "3333" }],
data = {"entype": [{"label": i.name, "value": i.nid} for i in typy],
"qualificat": [{"label": i.name, "value": i.nid} for i in qualificat],
"quoted": [{"label": i.name, "value": i.nid} for i in quoted],
"financ": [{"label": i.name, "value": i.nid} for i in financ],
"buildate": [{"label": "1-3年", "value": 1}, {"label": "3-5年", "value": 2},
{"label": "5-8年", "value": 3}, {"label": "8-10年", "value": 4},
{"label": "10-15年", "value": 5}, {"label": "15年以上", "value": 6}],
"capital": [{"label": "100万以内", "value": 1}, {"label": "100万-500万", "value": 2},
{"label": "500万-1000万", "value": 3}, {"label": "1000万-5000万", "value": 4},
{"label": "5000万-1亿", "value": 5}, {"label": "1亿以上", "value": 6}],
"district": [{"label": "小店区", "value": "小店区"}, {"label": "迎泽区", "value": "迎泽区"},
{"label": "杏花岭区", "value": "杏花岭区"}, {"label": "尖草坪区", "value": "尖草坪区"},
{"label": "万柏林区", "value": "万柏林区"}, {"label": "晋源区", "value": "晋源区"},
{"label": "清徐县", "value": "清徐县"}, {"label": "阳曲县", "value": "阳曲县"},
{"label": "娄烦县", "value": "娄烦县"}, {"label": "古交市", "value": "古交市"}],
# "district": [{"label": "小店区", "value": ""}, {"label": "迎泽区", "value": 2},
# {"label": "杏花岭区", "value": 3}, {"label": "尖草坪区", "value": 4},
# {"label": "万柏林区", "value": 5}, {"label": "晋源区", "value": 6},
# {"label": "清徐县", "value": 7}, {"label": "阳曲县", "value": 8},
# {"label": "娄烦县", "value": 9}, {"label": "古交市", "value": 10}]
}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", options=data)
# 太原市企业列表
@api_atlas.route('/industry/enterprise', methods=['POST'])
# @login_required
def enterprise():
'''太原市企业列表'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
entype = req_dict.get("entype") # 企业类型id
qualificat = req_dict.get("qualificat") # 企业资质id
capital = req_dict.get("capital") # 注册资本id
quoted = req_dict.get("quoted") # 上市板块
district = req_dict.get("district") # 太原市下区县
yearid = req_dict.get("yearid") # 成立时间年限id
roundid = req_dict.get("roundid") # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
product = req_dict.get("product") # 产业产品选择
company_name = req_dict.get("company_name") # 产业产品名称筛选
sorts = req_dict.get("sorts") # 排序 sorts "1"按时间降序 ，“2”按热度降序
# 校验参数完整性
if not all([inid, cate, page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == "1":
company = Company.query.filter_by(f_type=inid, city="太原市")
else:
company = Company.query.filter_by(c_type=inid, city="太原市")
# 企业类型
if entype:
company = company.filter_by(entypeid=entype)
# 企业资质
if qualificat:
if qualificat == 1:
company = company.filter_by(high_new=1)
if qualificat == 2:
company = company.filter_by(tbe=1)
if qualificat == 3:
company = company.filter_by(quoted_company=1)
if qualificat == 4:
company = company.filter_by(sxonhun=1)
if qualificat == 5:
company = company.filter_by(isfive=1)
if qualificat == 6:
company = company.filter_by(unicorn=1)
if qualificat == 7:
company = company.filter_by(dengl=1)
if qualificat == 8:
company = company.filter_by(zjtg=1)
if qualificat == 9:
company = company.filter_by(scale=1)
if qualificat == 10:
company = company.filter_by(serve=1)
# 注册资本
if capital:
company = company.filter_by(capital_id=capital)
# 上市板块
if quoted:
company = company.filter_by(public_id=quoted)
# 区域选择
if district:
company = company.filter_by(district=district)
# 成立时间id
if yearid:
company = company.filter_by(yearid=yearid)
# 融资轮次
if roundid:
company = company.filter_by(roundid=roundid)
if company_name:
company = company.filter(Company.company_name.like("%{}%".format(company_name)))
if product:
company = Company.query.filter(Company.product_all.like("%{}%".format(product)))
size = company.count()
if sorts == "1":
companys = company.order_by(Company.build_date.desc()).paginate(page, perpage).items # 企业热度倒序
else:
companys = company.order_by(Company.hots.desc()).paginate(page, perpage).items # 企业热度倒序
df = [{"id": i.id,
"company_name": i.company_name,
"hots": i.hots} for i in companys]
data = {"size": size, "df": df}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 行业信息总览
@api_atlas.route('/industry/overview', methods=['POST'])
# @login_required
def overview():
'''太原市行业信息总览'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
entype = req_dict.get("entype") # 企业类型id
qualificat = req_dict.get("qualificat") # 企业资质id
capital = req_dict.get("capital") # 注册资本id
quoted = req_dict.get("quoted") # 上市板块
district = req_dict.get("district") # 太原市下区县
yearid = req_dict.get("yearid") # 成立时间年限id
roundid = req_dict.get("roundid") # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
product = req_dict.get("product") # 产业产品选择
# 校验参数完整性
if not all([inid, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == "1":
company = Company.query.filter_by(f_type=inid, city="太原市")
else:
company = Company.query.filter_by(c_type=inid, city="太原市")
# 企业类型
if entype:
company = company.filter_by(entypeid=entype)
# 企业资质
if qualificat:
if qualificat == 1:
company = company.filter_by(high_new=1)
if qualificat == 2:
company = company.filter_by(tbe=1)
if qualificat == 3:
company = company.filter_by(quoted_company=1)
if qualificat == 4:
company = company.filter_by(sxonhun=1)
if qualificat == 5:
company = company.filter_by(isfive=1)
if qualificat == 6:
company = company.filter_by(unicorn=1)
if qualificat == 7:
company = company.filter_by(dengl=1)
if qualificat == 8:
company = company.filter_by(zjtg=1)
if qualificat == 9:
company = company.filter_by(scale=1)
if qualificat == 10:
company = company.filter_by(serve=1)
# 注册资本
if capital:
company = company.filter_by(capital_id=capital)
# 上市板块
if quoted:
company = company.filter_by(public_id=quoted)
# 区域选择
if district:
company = company.filter_by(district=district)
# 成立时间id
if yearid:
company = company.filter_by(yearid=yearid)
# 融资轮次
if roundid:
company = company.filter_by(roundid=roundid)
if product:
company = Company.query.filter(Company.product_all.like("%{}%".format(product)))
coms = company.count() # 企业总数
capital = round(float(company.with_entities(func.sum(Company.capital_nums)).scalar() if company.with_entities(
func.sum(Company.capital_nums)).scalar() else 0) / 10000, 2) # 注册资本单位万
taking = round(float(company.with_entities(func.sum(Company.takingn)).scalar() if company.with_entities(
func.sum(Company.takingn)).scalar() else 0) / 10000, 2) # 营收
profit = round(float(company.with_entities(func.sum(Company.profit)).scalar() if company.with_entities(
func.sum(Company.profit)).scalar() else 0) / 10000, 2) # 利润
# profit = "0" # 利润
pnums = round(float(company.with_entities(func.sum(Company.bao_num)).scalar() if company.with_entities(
func.sum(Company.bao_num)).scalar() else 0)) # 参保人数
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
data = {"coms": str(coms) + "户", "capital": str(capital) + "亿", "taking": str(taking) + "亿",
"pnums": str(pnums) + "人", "profit": str(profit) + "亿"}
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 太原市企业年度柱状图
@api_atlas.route('/industry/statistics', methods=['POST'])
# @login_required
def statistics():
'''太原市企业年度柱状图'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
entype = req_dict.get("entype") # 企业类型id
qualificat = req_dict.get("qualificat") # 企业资质id
capital = req_dict.get("capital") # 注册资本id
quoted = req_dict.get("quoted") # 上市板块
district = req_dict.get("district") # 太原市下区县
yearid = req_dict.get("yearid") # 成立时间年限id
roundid = req_dict.get("roundid") # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
product = req_dict.get("product") # 产业产品选择
# 校验参数完整性
if not all([inid, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == "1":
company = Company.query.filter_by(f_type=inid, city="太原市")
else:
company = Company.query.filter_by(c_type=inid, city="太原市")
# 企业类型
if entype:
company = company.filter_by(entypeid=entype)
# 企业资质
if qualificat:
if qualificat == 1:
company = company.filter_by(high_new=1)
if qualificat == 2:
company = company.filter_by(tbe=1)
if qualificat == 3:
company = company.filter_by(public_sector=1)
if qualificat == 4:
company = company.filter_by(sxonhun=1)
if qualificat == 5:
company = company.filter_by(isfive=1)
if qualificat == 6:
company = company.filter_by(unicorn=1)
if qualificat == 7:
company = company.filter_by(dengl=1)
if qualificat == 8:
company = company.filter_by(zjtg=1)
if qualificat == 9:
company = company.filter_by(scale=1)
if qualificat == 10:
company = company.filter_by(serve=1)
# 注册资本
if capital:
company = company.filter_by(capital_id=capital)
# 上市板块
if quoted:
company = company.filter_by(public_id=quoted)
# 区域选择
if district:
company = company.filter_by(district=district)
# 成立时间id
if yearid:
company = company.filter_by(yearid=yearid)
# 融资轮次
if roundid:
company = company.filter_by(roundid=roundid)
if product:
company = company.filter(Company.product_all.like("%{}%".format(product)))
yearn = datetime.now().year
data = {"register": [], "cpital": []}
for year in [str(y) for y in range(yearn - 4, yearn + 1)]:
data["register"].append(
{"year": year, "value": company.filter(extract("year", Company.build_date) == year).count()})
v = company.filter(extract("year", Company.build_date) == year).with_entities(
func.sum(Company.capital_nums)).scalar()
data["cpital"].append({"year": year, "value": round(float(v), 2) if v else 0})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 太原市创新资源机构类型筛选条件
@api_atlas.route('/innovate/fields', methods=['GET'])
def org_field():
'''创新资源机构列表'''
# data = {"class": [{"label": "高等院校", "value": 1}, {"label": "科研机构", "value": 2},
# {"label": "创新平台", "value": 3}, {"label": "产业服务平台", "value": 4}],
# "college": [{"label": "全部", "value": ""}, {"label": "211工程院校", "value": 1},
# {"label": "普通本科", "value": 2}, {"label": "高职高专", "value": 3}],
# "scenice": [],
# "creative": [{"label": "全部", "value": ""}, {"label": "工程技术中心", "value": 1},
# {"label": "国际科技合作基地", "value": 2},
# {"label": "企业技术中心", "value": 3}, {"label": "双创基地", "value": 4},
# {"label": "院士工作站", "value": 5}, {"label": "质量检测与测量中心", "value": 6},
# {"label": "重点实验室", "value": 7}],
# "induserve": [{"label": "全部", "value": ""}, {"label": "产业联盟", "value": 1},
# {"label": "公共服务平台", "value": 2}, {"label": "行业协会", "value": 3}]
# }
data = {"class": [{"label": "高等院校", "value": 1}, {"label": "科研机构", "value": 2},
{"label": "创新平台", "value": 3}, {"label": "产业服务平台", "value": 4}],
"college": [{"label": "全部", "value": ""}, {"label": "211工程院校", "value": 1},
{"label": "普通本科", "value": 2}, {"label": "高职高专", "value": 3}],
"scenice": [],
"creative": [{"label": "全部", "value": ""}, {"label": "工程技术中心", "value": 1},
{"label": "国际科技合作基地", "value": 2},
{"label": "企业技术中心", "value": 3}, {"label": "双创基地", "value": 4},
{"label": "重点实验室", "value": 7}],
"induserve": [{"label": "全部", "value": ""}, {"label": "产业联盟", "value": 1},
{"label": "公共服务平台", "value": 2}, {"label": "行业协会", "value": 3},
{"label": "院士工作站", "value": 4}, {"label": "质量检测与测量中心", "value": 5}]
}
return jsonify(code=RET.OK, msg="查询成功", options=data)
# 太原市创新资源机构分布图
@api_atlas.route('/innovate/distribute', methods=['POST'])
# @login_required
def innovate_distribute():
'''创新资源机构分布'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
district = req_dict.get("district") # 区县
# 校验参数完整性
if not all([inid, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
name = Industry.query.filter_by(nid=inid).first().oname # 真名
orgs = Orgs.query.with_entities(Orgs.category).distinct().all()
category = [i[0] for i in orgs] # 拿到类型的无重复值
data = []
if cate == "1": # f_type
if district:
orgs = Orgs.query.filter_by(admin=district).filter(Orgs.navigator.like("%{}%".format(name)))
else:
orgs = Orgs.query.filter(Orgs.navigator.like("%{}%".format(name)))
for cate in category:
nums = orgs.filter_by(category=cate).count()
data.append({"label": cate, "value": nums})
else:
if district:
orgs = Orgs.query.filter_by(admin=district).filter(Orgs.navigat.like("%{}%".format(name)))
else:
orgs = Orgs.query.filter(Orgs.navigat.like("%{}%".format(name)))
for cate in category:
nums = orgs.filter_by(category=cate).count()
data.append({"label": cate, "value": nums})
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 太原市创新资源机构列表（高等院校和告高职转告合并，高职专高作为第二分类，合并两个表）
@api_atlas.route('/innovate/orgs', methods=['POST'])
# @login_required
def orgs():
'''创新资源机构列表'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
cateone = req_dict.get("cateone") # 机构类型id. 高等院校1,科研机构2，创新平台3，产业服务平台4
catetwo = req_dict.get("catetwo") # 机构类型2 id
product = req_dict.get("product") # 产品
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
# 校验参数完整性
if not all([inid, cate, cateone, page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
name = Industry.query.filter_by(nid=inid).first().oname
if cateone == 1: # 高等院校
try:
if cate == "1":
college = College.query.filter(College.navigator.like("%{}%".format(name)))
else:
college = College.query.filter(College.navigat.like("%{}%".format(name)))
if catetwo:
college = college.filter_by(cateid=catetwo)
if product:
college = college.filter(College.research.like("%{}%".format(product)))
size = college.count()
college = college.paginate(page, perpage).items
data = {"df": [{"id": i.id,
"name": i.name,
"cate": i.category,
"cateone": cateone} for i in college],
"size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DATAERR, msg="参数错误")
elif cateone == 2: # 科研机构
if cate == "1":
scientific = Scientific.query.filter(Scientific.navigator.like("%{}%".format(name)))
else:
scientific = Scientific.query.filter(Scientific.navigat.like("%{}%".format(name)))
if product:
scientific = scientific.filter(Scientific.research.like("%{}%".format(product)))
size = scientific.count()
scientific = scientific.paginate(page, perpage).items
data = {"df": [{"id": i.id,
"name": i.name,
"cate": "科研机构",
"cateone": cateone} for i in scientific],
"size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
elif cateone == 3: # 创新平台3
if cate == "1":
lab = Lab.query.filter(Lab.navigator.like("%{}%".format(name)))
else:
lab = Lab.query.filter(Lab.navigat.like("%{}%".format(name)))
if catetwo:
lab = lab.filter_by(cateid=catetwo)
if product:
lab = lab.filter(Lab.research.like("%{}%".format(product)))
size = lab.count()
lab = lab.paginate(page, perpage).items
data = {"df": [{"id": i.id,
"name": i.name,
"cate": i.cate,
"cateone": cateone} for i in lab],
"size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
elif cateone == 4: # 产业服务平台
if cate == "1":
platform = Platform.query.filter(Platform.navigator.like("%{}%".format(name)))
else:
platform = Platform.query.filter(Platform.navigat.like("%{}%".format(name)))
if catetwo:
platform = platform.filter_by(cateid=catetwo)
if product:
platform = platform.filter(Platform.research.like("%{}%".format(product)))
size = platform.count()
platform = platform.paginate(page, perpage).items
data = {"df": [{"id": i.id,
"name": i.name,
"cate": i.cate,
"cateone": cateone} for i in platform],
"size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.PARAMERR, msg="参数错误")
# 产业发展图谱资源机构页面的散点图地图
@api_atlas.route('/orgs/sdmap', methods=['POST'])
# @login_required
def orgs_sdmap():
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
cateone = req_dict.get("cateone") # 机构类型id. 高等院校1,科研机构2，创新平台3，产业服务平台4
catetwo = req_dict.get("catetwo") # 机构类型2 id
product = req_dict.get("product") # 产品
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
# 校验参数完整性
if not all([inid, cate, cateone]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
name = Industry.query.filter_by(nid=inid).first().oname
if cateone == 1: # 高等院校
try:
if cate == "1":
college = College.query.filter(College.navigator.like("%{}%".format(name)))
else:
college = College.query.filter(College.navigat.like("%{}%".format(name)))
if catetwo:
college = college.filter_by(cateid=catetwo)
if product:
college = college.filter(College.research.like("%{}%".format(product)))
college = college.paginate(page, perpage).items
data = [{"id": com.id,
"name": com.name,
"jwd": {"lng": com.lng, # 园区地址出的经纬度
"lat": com.lat}
} for com in college]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DATAERR, msg="参数错误")
elif cateone == 2: # 科研机构
if cate == "1":
scientific = Scientific.query.filter(Scientific.navigator.like("%{}%".format(name)))
else:
scientific = Scientific.query.filter(Scientific.navigat.like("%{}%".format(name)))
if product:
scientific = scientific.filter(Scientific.research.like("%{}%".format(product)))
scientific = scientific.paginate(page, perpage).items
data = [{"id": com.id,
"name": com.name,
"jwd": {"lng": com.lng, # 园区地址出的经纬度
"lat": com.lat}
} for com in scientific]
return jsonify(code=RET.OK, msg="查询成功", data=data)
elif cateone == 3: # 创新平台3
if cate == "1":
lab = Lab.query.filter(Lab.navigator.like("%{}%".format(name)))
else:
lab = Lab.query.filter(Lab.navigat.like("%{}%".format(name)))
if catetwo:
lab = lab.filter_by(cateid=catetwo)
if product:
lab = lab.filter(Lab.research.like("%{}%".format(product)))
lab = lab.paginate(page, perpage).items
data = [{"id": com.id,
"name": com.name,
"jwd": {"lng": com.lng, # 园区地址出的经纬度
"lat": com.lat}
} for com in lab]
return jsonify(code=RET.OK, msg="查询成功", data=data)
elif cateone == 4: # 产业服务平台
if cate == "1":
platform = Platform.query.filter(Platform.navigator.like("%{}%".format(name)))
else:
platform = Platform.query.filter(Platform.navigat.like("%{}%".format(name)))
if catetwo:
platform = platform.filter_by(cateid=catetwo)
if product:
platform = platform.filter(Platform.research.like("%{}%".format(product)))
platform = platform.paginate(page, perpage).items
data = [{"id": com.id,
"name": com.name,
"jwd": {"lng": com.lng, # 园区地址出的经纬度
"lat": com.lat}
} for com in platform]
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.PARAMERR, msg="参数错误")
# 太原园区列表及所有园区的数量及面积（默认全部）
@api_atlas.route('/carrier/garden', methods=['POST'])
# @login_required
def garden():
'''创新资源机构列表'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
keyword = req_dict.get("keyword") # 搜索园区姓名
level = req_dict.get("level") # 园区级别
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid:
name = Industry.query.filter_by(nid=inid).first().oname # 获取导航对应的真名
if cate == "1":
induzone = Induzone.query.filter(Induzone.navigator.like("%{}%".format(name)))
else:
induzone = Induzone.query.filter(Induzone.navigat.like("%{}%".format(name)))
else:
induzone = Induzone.query.filter_by()
if keyword:
induzone = induzone.filter(Induzone.name.like("%{}%".format(keyword))) # 查询词
if level:
induzone = induzone.filter_by(level=level) # 园区级别筛选
# count = induzone.count() # 园区总数
count_x = induzone.filter_by(cate="行政区").count() # 园区总数
count_y = induzone.filter_by(cate="产业园区").count() # 产业园区总数
# areas = induzone.with_entities(func.sum(Induzone.area)).scalar() # 园区总面积
size = induzone.count() # 分页总数
induzone = induzone.paginate(page, perpage).items
data = {"garden": [{"id": i.id,
"name": i.name,
"level": i.level if i.level else "",
"cate": i.cate if i.cate else "",
"cluster": i.cluster if i.cluster else ""} for i in induzone],
"size": size,
# "df": {"count": count,
# "areas": round(areas, 2) if areas else "-"},
"df": {"count_x": count_x, # 行政区数
"count_y": count_y} # 园区数
}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="查询成功", data=data)
# 太原园区列表及所有园区的数量及面积（默认全部）
@api_atlas.route('/carrier/gardens', methods=['POST'])
def gardens():
'''创新资源机构列表'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
keyword = req_dict.get("keyword") # 搜索园区姓名
level = req_dict.get("level") # 园区级别
clasify = req_dict.get("clasify") # 园区类别，行政区、产业园区
# 校验参数完整性
if not all([page, perpage, clasify]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid:
name = Industry.query.filter_by(nid=inid).first().oname # 获取导航对应的真名
if cate == "1":
induzone = Induzone.query.filter(Induzone.navigator.like("%{}%".format(name)))
else:
induzone = Induzone.query.filter(Induzone.navigat.like("%{}%".format(name)))
else:
induzone = Induzone.query.filter_by()
if level:
induzone = induzone.filter_by(level=level) # 园区级别筛选
count_x = induzone.filter_by(cate="行政区").count() # 园区总数
count_y = induzone.filter_by(cate="产业园区").count() # 产业园区总数
if clasify == "行政区":
induzone = induzone.filter_by(cate="行政区")
elif clasify == "产业园区":
induzone = induzone.filter_by(cate="产业园区")
if keyword:
# induzone = induzone.filter(Induzone.name.like("%{}%".format(keyword))) # 查询词
induzone = Induzone.query.filter(Induzone.name.like("%{}%".format(keyword))) # 查询词
size = induzone.count() # 分页总数
induzone = induzone.paginate(page, perpage).items
data = {"garden": [{"id": i.id,
"name": i.name, # 园区名
"level": i.level if i.level else "", # 园区级别
"cate": i.cate if i.cate else "", # 园区类型
"cluster": i.cluster if i.cluster else "", # 产业集群
"address": i.address if i.address else "", # 园区地址
"area": str(i.area) + "平方公里" if i.area else "", # 园区面积
} for i in induzone],
"size": size,
"df": {"count_x": count_x, # 行政区数
"count_y": count_y} # 园区数
}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="查询成功", data=data)
# 产业发展图谱产业载体园区的散点图地图(2020-11-7)
@api_atlas.route('/zone/sdmap', methods=['POST'])
# @login_required
def zone_sdmap():
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
keyword = req_dict.get("keyword") # 搜索园区姓名
level = req_dict.get("level") # 园区级别
clasify = req_dict.get("clasify") # 园区类别，行政区、产业园区
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid:
name = Industry.query.filter_by(nid=inid).first().oname # 获取导航对应的真名
if cate == "1":
induzone = Induzone.query.filter(Induzone.navigator.like("%{}%".format(name)))
else:
induzone = Induzone.query.filter(Induzone.navigat.like("%{}%".format(name)))
else:
induzone = Induzone.query.filter_by()
if keyword:
induzone = induzone.filter(Induzone.name.like("%{}%".format(keyword))) # 查询词
if level:
induzone = induzone.filter_by(level=level) # 园区级别筛选
if clasify == "行政区":
induzone = induzone.filter_by(cate="行政区")
elif clasify == "产业园区":
induzone = induzone.filter_by(cate="产业园区")
induzone = induzone.paginate(page, perpage).items
data = [{"id": com.id,
"name": com.name,
"jwd": {"lng": com.lng, # 园区地址出的经纬度
"lat": com.lat}
} for com in induzone]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="查询成功", data=data)
'''产业下企业、资源机构及园区的色块图、散点图'''
# 按数量进行颜色的选择
def jisuan(num):
if num >= 0 and num <= 10:
return "#72D4F1"
if num > 10 and num <= 30:
return "#00BAF6"
if num > 30 and num <= 50:
return "#4F9FFF"
if num > 50 and num <= 100:
return "#4265F6"
if num > 100 and num <= 200:
return "#0052d6"
if num > 200:
return "#0245AE"
# 产业发展图谱企业页面太原市的色块图地图(2020-11-7)
@api_atlas.route('/enterprise/piecemap', methods=['POST'])
# @login_required
def enterprise_piecemap():
'''获取太原市下区县企业数量色块图'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,
if cate != "1":
return jsonify(code=RET.PARAMERR, msg="参数错误")
try:
district = Company.query.filter_by(city="太原市").with_entities(Company.district).distinct().all()
# print(district)
district = [i[0] for i in district] # 拿到区县的无重复值
company = Company.query.filter_by(city="太原市", f_type=inid)
# 太原市经纬度
tyjwd = [112.549, 37.957]
df = list()
for dis in district:
data_district = company.filter_by(district=dis)
com = Company.query.filter_by(city="太原市", district=dis).first()
df.append({"name": dis,
"value": data_district.count(),
"jwd": {"lng": com.d_lng, "lat": com.d_lat}, # 区县的经纬度
"color": jisuan(data_district.count())})
data = {"ty": tyjwd, "df": df}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 企业坐标图例
def get_color(s):
iphost = "http://39.100.39.50:8006"
# iphost = "192.168.1.127:5000"
if s == "上游":
return "{}/static/legend/red.png".format(iphost)
if s == "中游":
return "{}/static/legend/bule.png".format(iphost)
if s == "下游":
return "{}/static/legend/yellow.png".format(iphost)
return "{}/static/legend/green.png".format(iphost)
# 产业发展图谱企业页面的散点图地图(2020-11-7)
@api_atlas.route('/enterprise/sdmap', methods=['POST'])
# @login_required
def enterprise_sdmap():
'''产业发展图谱企业页面的散点图地图,1级导航必须有区县，2级导航可有可无'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,
district = req_dict.get("district") # 区县
product = req_dict.get("product") # 产品
try:
if cate != "2" and district == "":
return jsonify(code=RET.PARAMERR, msg="参数错误le")
if cate == "1": # 一级导航
company = Company.query.filter_by(city="太原市", f_type=inid)
if product:
company = company.filter(Company.product_all.like("%{}%".format(product)))
if district:
company = company.filter_by(district=district)
company = company.all()
data = []
for com in company:
data.append({"id": com.id,
"name": com.company_name,
"jwd": {"lng": com.lng, # 企业地址出的经纬度
"lat": com.lat},
"stream": get_color(com.stream)}) # 上下中游
return jsonify(code=RET.OK, msg="查询成功", data=data)
if cate == "2": # 二级导航
company = Company.query.filter_by(city="太原市", c_type=inid)
if product:
company = company.filter(Company.product_all.like("%{}%".format(product)))
if district:
company = company.filter_by(district=district)
company = company.all()
data = []
for com in company:
data.append({"id": com.id,
"name": com.company_name,
"jwd": {"lng": com.lng, # 企业地址出的经纬度
"lat": com.lat},
"stream": get_color(com.stream)}) # 上下中游
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.PARAMERR, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# # 产业发展图谱资源机构页面的散点图地图
# @api_atlas.route('/orgs/sdmap', methods=['POST'])
# # @login_required
# def orgs_sdmap():
# '''产业发展图谱资源机构页面的散点图地图'''
# req_dict = request.get_json()
# inid = req_dict.get("inid") # 行业id
# cate = req_dict.get("cate") # 行业等级,
# district = req_dict.get("district") # 区县
# product = req_dict.get("product") # 产品-research
#
# try:
# name = Industry.query.filter_by(nid=inid, statu=1).first().oname
# if cate == "1":
# orgs = Orgs.query.filter(Orgs.navigator.like("%{}%".format(name)))
# else:
# orgs = Orgs.query.filter(Orgs.navigat.like("%{}%".format(name)))
# if product:
# orgs = Orgs.query.filter(Orgs.research.like("%{}%".format(product)))
# if district:
# orgs = orgs.filter_by(admin=district)
# orgs = orgs.all()
# data = []
# for com in orgs:
# data.append({"id": com.id,
# "name": com.name,
# "jwd": {"lng": com.lng, # 园区地址出的经纬度
# "lat": com.lat}
# })
#
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
# return jsonify(code=RET.OK, msg="查询成功", data=data)
#
# # 产业发展图谱产业载体园区的散点图地图(2020-11-7)
# @api_atlas.route('/zone/sdmap', methods=['POST'])
# # @login_required
# def zone_sdmap():
# '''产业发展图谱产业载体页面的散点图地图'''
# req_dict = request.get_json()
# inid = req_dict.get("inid") # 行业id
# cate = req_dict.get("cate") # 行业等级,
# district = req_dict.get("district") # 区县
#
# try:
# name = Industry.query.filter_by(nid=inid, statu=1).first().oname
# if cate == "1":
# induzone = Induzone.query.filter(Induzone.navigator.like("%{}%".format(name)))
# else:
# induzone = Induzone.query.filter(Induzone.navigat.like("%{}%".format(name)))
# if district:
# induzone = induzone.filter_by(region=district)
#
# induzone = induzone.all()
#
# data = []
# for com in induzone:
# data.append({"id": com.id,
# "name": com.name,
# "jwd": {"lng": com.lng, # 园区地址出的经纬度
# "lat": com.lat}
# })
#
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
# return jsonify(code=RET.OK, msg="查询成功", data=data)
apps/atlas/view_detail.py 0 → 100644
import json
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import CommonRequest
from flask import current_app, request, jsonify
from apps.models import *
from apps.atlas import api_atlas
from apps.util import login_required, verify_token
from apps.utils.response_code import RET
# 企业信息详情
@api_atlas.route('/enterprise/detail', methods=['POST'])
@login_required
def enterprise_detail():
'''
企业信息详情
:return:
'''
# 获取用户id
token = request.headers["token"]
user = verify_token(token)
user_id = user.id # 用户id
req_dict = request.get_json()
_id = req_dict.get("id") # 企业id
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
company = Company.query.get(_id)
user = User.query.get(user_id) # 获取关注列表
if user:
company_ids = [coms.id for coms in user.company]
else:
company_ids = []
if company:
data = {"id": company.id,
"company_name": company.company_name,
"telephone": company.telephone if company.telephone else "-",
"web_site": company.web_site if company.web_site else "-",
"email": company.email if company.email else "-",
"address": company.address if company.address else "-",
"jwd": {"lng": company.lng if company.lng else "-",
"lat": company.lat if company.lat else "-"},
"company_info": company.company_info if company.company_info else "-",
"high_new": "高新技术企业" if company.high_new == "1" else "",
"isfive": "500强企业" if company.isfive == "1" else "", # 500强
"quoted_company": "上市企业" if company.quoted_company == "1" else "", # 上市企业
"tbe": "科技型中小企业" if company.tbe == "1" else "", # 科技型中小企业
"unicorn": "独角兽企业" if company.unicorn == "1" else "", # 独角兽企业
"dengl": "瞪羚企业" if company.dengl == "1" else "", # 瞪羚企业
"legal": company.legal if company.legal else "-",
"status": company.status if company.status else "-",
"build_date": str(company.build_date)[:10] if company.build_date else "-",
"capital": company.capital if company.capital else "-",
"social_code": company.social_code if company.social_code else "-",
"taking": company.takingn if company.takingn else "-",
"bao": company.bao_num if company.bao_num else "-",
"entype": company.entype if company.entype else "-",
"industry": company.company_industry if company.company_industry else "-",
"scope": company.business_scope if company.business_scope else "-",
"collect": "1" if company.id in company_ids else "2", # 关注状态码1关注，2未关注
"choice": "1" # 1太原企业，2全国企业
}
else:
return jsonify(code=RET.NODATA, msg="查无数据")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 企业收藏与取消
@api_atlas.route('/enterprise/collect', methods=['POST'])
@login_required
def enter_collect():
'''
企业收藏与取消
:return:
'''
# 获取用户id
token = request.headers["token"]
user = verify_token(token)
user_id = user.id # 用户id
# user_id = 1
req_dict = request.get_json()
_id = req_dict.get("id") # 企业id
choice = req_dict.get("choice") # 1太原企业，2全国企业
collect = req_dict.get("collect") # 关注状态(1是，2否)
# 校验参数完整性
if not all([_id, choice, collect]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if choice == "1": # 太原企业
if collect == "2": # 未关注，我要关注
user = User.query.get(user_id)
coms = Company.query.get(_id)
user.company.append(coms)
db.session.commit()
return jsonify(code=RET.OK, msg="收藏成功", collect="1")
elif collect == "1": # 已关注，我要取关
user = User.query.get(user_id)
coms = Company.query.get(_id)
user.company.remove(coms)
db.session.commit()
return jsonify(code=RET.OK, msg="取消收藏", collect="2")
else:
return jsonify(code=RET.DATAERR, msg="参数异常")
if choice == "2": # 全国企业
if collect == "2": # 未关注，我要关注
user = User.query.get(user_id)
enters = Enterprise.query.get(_id)
user.enterprise.append(enters)
db.session.commit()
return jsonify(code=RET.OK, msg="收藏成功", collect="1")
elif collect == "1": # 已关注，我要取关
user = User.query.get(user_id)
enters = Enterprise.query.get(_id)
user.enterprise.remove(enters)
db.session.commit()
return jsonify(code=RET.OK, msg="取消收藏", collect="2")
else:
return jsonify(code=RET.DATAERR, msg="状态参数异常")
else:
return jsonify(code=RET.DATAERR, msg="企业类别参数异常")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 资源机构详情
@api_atlas.route('/orgs/detail', methods=['POST'])
# @login_required
def orgs_detail():
'''
资源机构详情
:return:
'''
req_dict = request.get_json()
_id = req_dict.get("id") # 机构id
cate = req_dict.get("cateone") # 机构类型
# 校验参数完整性
if not all([_id, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
# 高等院校
if cate == 1:
college = College.query.get(_id)
if college:
data = {"id": college.id,
"name": college.name, # 名称
"charge": college.charge if college.charge else "-", # 主管部门
"category": college.category if college.category else "-", # 学校类型
"buildate": str(college.buildate) if college.buildate else "-", # 创办时间
"nature": college.nature if college.nature else "-", # 办学性质
"address": college.address if college.address else "-", # 地址
"clas": college.clas if college.clas else "-", # 学校类别
"ccode": college.ccode if college.ccode else "-", # 学校代码
"major": college.major if college.major else "-", # 专业
"faculty": college.faculty if college.faculty else "-", # 院系设置
"feature": college.feature if college.feature else "-", # 学校特色
"introduct": college.introduct if college.introduct else "-", # 简介
"research": college.research if college.research else "-", # 研究方向
"jwd": {"lng": college.lng if college.lng else "-",
"lat": college.lat if college.lat else "-"}
}
return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
return jsonify(code=RET.NODATA, msg="无数据")
# 科研机构
elif cate == 2:
college = Scientific.query.get(_id)
if college:
data = {"id": college.id,
"name": college.name, # 机构名称
"telephone": college.telephone if college.telephone else "-", # 电话
"fax": college.fax if college.fax else "-", # 传真
"address": college.address if college.address else "-", # 地址
"postcode": college.postcode if college.postcode else "-", # 邮编
"introduct": college.introduct if college.introduct else "-", # 机构简介
"jwd": {"lng": college.lng if college.lng else "-",
"lat": college.lat if college.lat else "-"}
}
return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
return jsonify(code=RET.NODATA, msg="无数据")
# 创新平台
elif cate == 3:
college = Lab.query.get(_id)
if college:
data = {"id": college.id,
"name": college.name, # 平台名称
"introduct": college.introduct if college.introduct else "-",
"address": college.address if college.address else "-", # 地址
"jwd": {"lng": college.lng if college.lng else "-",
"lat": college.lat if college.lat else "-"}
}
return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
return jsonify(code=RET.NODATA, msg="无数据")
# 产业服务平台
elif cate == 4:
college = Platform.query.get(_id)
if college:
data = {"id": college.id,
"name": college.name,
"introduct": college.introduct if college.introduct else "-",
"address": college.address if college.address else "-",
"research": college.research if college.research else "-",
"jwd": {"lng": college.lng if college.lng else "-",
"lat": college.lat if college.lat else "-"}
}
return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
return jsonify(code=RET.NODATA, msg="无数据")
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# print(get_img_url("690a08cb0aa94b7498ba13b549ee2deb"))
# 太原园区详情
@api_atlas.route('/carrier/detail', methods=['POST'])
# @login_required
def garden_detail():
req_dict = request.get_json()
_id = req_dict.get("id") # 园区id
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
iz = Induzone.query.get(_id)
if iz:
data = {"id": iz.id,
"name": iz.name, # 园区名
"image": str(iz.image), # 园区图片
"level": iz.level, # 园区级别
"cate": iz.cate, # 园区类型
"charge": iz.charge if iz.charge else "-", # 负责人
"phone": iz.phone if iz.phone else "-", # 联系电话
"address": iz.address if iz.address else "-", # 所在地
"cluster": iz.cluster if iz.cluster else "-", # 产业集群
"detail": {"acreage": str(iz.area) + "平方公里" if iz.area else "-", # 占地面积
"actarea": str(iz.actarea) + "平方公里" if iz.actarea else "-", # 建成面基
"tax": str(iz.tax) + "万元/亩" if iz.tax else "-", # 税收要求
"out_power": str(iz.out_power) + "万元/亩" if iz.out_power else "-", # 产出强度
"invest_power": str(iz.invest_power) + "万元/亩" if iz.invest_power else "-", # 投资强度
"indu_need": iz.indu_need if iz.indu_need else "-", # 行业要求
"gdp": str(iz.gdp) + "亿元" if iz.gdp else "-", # gdp
"fiscal": str(iz.fiscal) + "亿元" if iz.fiscal else "-", # 财政收入（亿元）
"indu_land": iz.indu_land if iz.indu_land else "-", # 工业土地均价
"indu_sup": iz.indu_sup if iz.indu_sup else "-", # 工业土地供应量
"comm_land": iz.comm_land if iz.comm_land else "-", # 商办土地均价
"comm_sup": iz.comm_sup if iz.comm_sup else "-", # 商办土地供应量
"represent": iz.represent if iz.represent else "-" # 代表企业
},
"invest": {"resident_ele_one": iz.resident_ele_one + "元/度" if iz.resident_ele_one else "-", # 居民电价一
"resident_ele_two": iz.resident_ele_two + "元/度" if iz.resident_ele_two else "-", # 居民电价二
"resident_ele_thr": iz.resident_ele_thr + "元/度" if iz.resident_ele_thr else "-", # 居民电价三
"comm_ele_one": iz.comm_ele_one + "元/度" if iz.comm_ele_one else "-", # 商业用电1
"comm_ele_two": iz.comm_ele_two + "元/度" if iz.comm_ele_two else "-", # 商业用电2
"comm_ele_thr": iz.comm_ele_thr + "元/度" if iz.comm_ele_thr else "-", # 商业用电3
"indu_ele_one": iz.indu_ele_one + "元/度" if iz.indu_ele_one else "-", # 工业用电1
"indu_ele_two": iz.indu_ele_two + "元/度" if iz.indu_ele_two else "-", # 工业用电2
"indu_ele_thr": iz.indu_ele_thr + "元/度" if iz.indu_ele_thr else "-", # 工业用电3
"resident_water_one": iz.resident_water_one + "元/吨" if iz.resident_water_one else "-",
# 居民用水1
"resident_water_two": iz.resident_water_two + "元/吨" if iz.resident_water_two else "-",
# 居民用水2
"resident_water_thr": iz.resident_water_thr + "元/吨" if iz.resident_water_thr else "-",
# 居民用水3
"comm_water": iz.comm_water + "元/吨" if iz.comm_water else "-", # 商业用水
"indu_water": iz.indu_water + "元/吨" if iz.indu_water else "-", # 工业用水
"special_water": iz.special_water + "元/吨" if iz.special_water else "-", # 特殊用水
"resident_natgas_one": iz.resident_natgas_one + "元/m³" if iz.resident_natgas_one else "-",
# 居民用气1
"resident_natgas_two": iz.resident_natgas_two + "元/m³" if iz.resident_natgas_two else "-",
# 居民用气1
"resident_natgas_thr": iz.resident_natgas_thr + "元/m³" if iz.resident_natgas_thr else "-",
# 居民用气1
"sewage": iz.sewage + "元/吨" if iz.sewage else "-", # 污水处理
"wagelevel": iz.wagelevel + "元/月" if iz.wagelevel else "-", # 最低工资
"worker": iz.worker + "元/月" if iz.worker else "-", # 普通员工
"middlemag": iz.middlemag + "元/月" if iz.middlemag else "-", # 中级管理
"highmag": iz.highmag + "元/月" if iz.highmag else "-", # 高级管理
},
"config": {"dis_freight": iz.dis_freight if iz.dis_freight else "-", # 距离货运站距离
"dis_port": iz.dis_port if iz.dis_port else "-", # 距离港口距离
"dis_rail": iz.dis_rail if iz.dis_rail else "-", # 距离高铁距离
"dis_air": iz.dis_air if iz.dis_air else "-", # 距离机场距离
"road_trans": iz.road_trans if iz.road_trans else "-", # 公路运输
"rail_trans": iz.rail_trans if iz.rail_trans else "-", # 铁路运输
"live_facility": iz.live_facility if iz.live_facility else "-", # 园区生活配套
"market": iz.market if iz.market else "-", # 百货
"hotel_bus": iz.hotel_bus if iz.hotel_bus else "-", # 酒店商务
"medical": iz.medical if iz.medical else "-", # 医疗
"education": iz.education if iz.education else "-" # 教育
},
"indevo": {"induenterprise": iz.induenterprise if iz.induenterprise else "-", # 规模以上企业
"innovate": iz.innovate if iz.innovate else "-", # 科研机构
"base": iz.base if iz.base else "-", # 双创基地
"carrier": iz.carrier if iz.carrier else "-", # 产业载体
}, # 产业发展
"intriduce": iz.introduct if iz.introduct else "-", # 园区介绍
"jwd": {"lng": iz.lng if iz.lng else "-", # 经度
"lat": iz.lat if iz.lat else "-"}
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.PARAMERR, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
apps/atlas/view_es.py 0 → 100644
import json
import requests
from sqlalchemy import or_
from flask import g, current_app, request, jsonify, session
from apps.atlas import api_atlas
from apps.util import login_required
from apps.utils.response_code import RET
from apps.models import *
# 创建body
def create_body(page, page_size, query, args_term, args_cate, args_org):
'''
:param page:
:param page_size:
:param args_query:
:param args_date:
:param args_term:
:return:
https://www.cnblogs.com/yjf512/p/4897294.html
'''
if query:
body = {
"query": {
"bool": {
"must": [{"multi_match": {"query": "{}".format(query),
# "type": "best_fields",
"fields": [
"name^1000.0",
"body^1.0",
# "org^5.0",
# "navigator^5.0",
# "navigat^5.0"
],
"tie_breaker": 0.3
}
}
]
}
},
"from": (page - 1) * page_size,
"size": page_size,
"sort": {},
"aggs": {},
"_source": [
"name", "org", "pubdate", "policyid"
],
"highlight": {}
}
else:
body = {
"query": {
"bool": {
"must": [{"match_all": {}
}
]
}
},
"from": (page - 1) * page_size,
"size": page_size,
"sort": {"pubdate": {"order": "desc"}},
"aggs": {},
"_source": [
"name", "org", "pubdate", "policyid"
],
"highlight": {}
}
if args_cate:
body["query"]["bool"]["must"].append(
{"multi_match": {"query": "{}".format(args_cate["indu"]), # match_phrase来实现完全匹配查询（精准模糊查询）。
"type": "phrase",
"fields": [
"navigator^5.0",
"navigat^5.0"
],
"slop": 0,
}
})
if args_org:
body["query"]["bool"]["must"].append(
{"multi_match": {"query": "{}".format(args_org["org"]), # match_phrase来实现完全匹配查询（精准模糊查询）。
"type": "phrase",
"fields": [
"org"
],
"slop": 0,
}
})
for k, v in args_term.items():
body["query"]["bool"]["must"].append({"term": {"{}".format(k): "{}".format(v)}})
# print(body)
return body
# 机构省市区选择（2021-1-7）
@api_atlas.route("/selectArea", methods=['GET'])
def select_area():
'''机构省市区选择'''
result = [{"label": "国家", "value": 5}, {"label": "省级", "value": 1}, {"label": "市级", "value": 2},
{"label": "区县", "value": 3}, {"label": "开发区", "value": 4}]
return jsonify(code=RET.OK, msg="查询成功", data=result)
# 发布机构（根据省市区获取）（2021-1-7）
@api_atlas.route("/areaCategory", methods=['POST'])
def area_category():
'''发布机构'''
req_dict = request.get_json()
vau = req_dict.get("vau") # 省1、市2、区县3、开发区4
# 校验参数完整性
if not all([vau]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
country = ["国务院"]
# province = ["山西省政府", "省政府办公厅", "省发展和改革委员会", "省科学技术厅", "省工业和信息化厅", "省人力资源和社会保障厅", "省生态环境厅", "省商务厅", "其他"]
province = ["山西省委", "山西省政府"]
# city = ["太原市政府", "市政府办公厅", "市发展改革委", "市科技局", "市工信局", "市人社局", "市生态环境局", "市商务局", "市文旅局", "市外来投资局", "市大数据局", "其他"]
city = ["太原市委", "太原市政府"]
district = ["小店区政府", "迎泽区政府", "杏花岭区政府", "尖草坪区政府", "万柏林区政府", "晋源区政府", "古交市政府", "清徐县政府", "阳曲县政府", "娄烦县政府", "其他"]
dev = ["山西转型综合改革示范区", "中北高新区", "清徐经济开发区", "阳曲现代农业产业示范区", "西山生态文化旅游示范区", "其他"]
if vau == 5: # 国家
result = [{"label": name, "value": country.index(name)} for name in country]
elif vau == 1: # 省，默认
result = [{"label": name, "value": province.index(name)} for name in province]
elif vau == 2: # 市
result = [{"label": name, "value": city.index(name)} for name in city]
elif vau == 3: # 区
result = [{"label": name, "value": district.index(name)} for name in district]
elif vau == 4: # 县
result = [{"label": name, "value": dev.index(name)} for name in dev]
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
return jsonify(code=RET.OK, msg="查询成功", data=result)
'''
url = "http://127.0.0.1:9200/typolicy/_search"
'''
# 太原产业政策列表(转es)（小程序调用，不可删除）
@api_atlas.route('/industry/policy', methods=['POST'])
# @login_required
def indupolicy():
'''
太原产业政策列表(第一版用mysql,全文搜索，准备改用用es)
根据条件多字段搜索
:return:model-InduPolicy
'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
category = req_dict.get("category") # 政策类型
org = req_dict.get("org") # 发布机构
year = req_dict.get("year") # 发布年份
keyword = req_dict.get("keyword") # 搜索园区内容
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
if org == "省级":
org = "山西省政府"
if org == "市级":
org = "太原市政府"
if org == "区县":
org = "小店区政府"
if org == "开发区":
org = "山西省转型综合改革示范区"
if org == "山西转型综合改革示范区":
org = "山西省转型综合改革示范区"
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
query = "" # 要查询的关键词
args_term = dict() # 要匹配的字段
args_cate = dict() # 要多字段(两导航)完全匹配
args_org = dict() # 要多字段(两导航)完全匹配
if keyword:
query = keyword
if category:
args_term["category"] = category
if org:
args_org["org"] = org
if year:
args_term["year"] = year
if inid:
indu_name = Industry.query.filter_by(nid=inid).first().oname
args_cate["indu"] = indu_name
body = create_body(page, perpage, query, args_term, args_cate, args_org)
try:
url = "http://127.0.0.1:9200/typolicy/_search"
# url = "http://127.0.0.1:9200/newindex/_search"
result_es = json.loads(requests.post(url=url, json=body).text)
# print(result_es)
data = []
size = result_es["hits"]["total"]
for item in result_es["hits"]["hits"]:
data.append({"name": item["_source"]["name"],
"org": item["_source"]["org"],
"pubdate": str(item["_source"]["pubdate"]),
"id": item["_source"]["policyid"]})
result = {"data": data, "size": size}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="查询成功", data=result)
# # 太原产业政策列表(转es)（pc更新）
# @api_atlas.route('/industry/policyList', methods=['POST'])
# # @login_required
# def policy_list():
# '''
# 太原产业政策列表(第一版用mysql,全文搜索，准备改用用es)
# 根据条件多字段搜索
# :return:model-InduPolicy
# '''
# req_dict = request.get_json()
#
# inid = req_dict.get("inid") # 行业id
#
# category = req_dict.get("category") # 政策类型
# level = req_dict.get("level") # 发布级别
# org = req_dict.get("org") # 发布机构
# year = req_dict.get("year") # 发布年份
# keyword = req_dict.get("keyword") # 搜索园区内容
#
# page = req_dict.get("page") # 分页页码
# perpage = req_dict.get("perpage") # 分页大小
#
# if org == "省级":
# org = "山西省政府"
# if org == "市级":
# org = "太原市政府"
# if org == "区县":
# org = "小店区政府"
# if org == "开发区":
# org = "山西转型综合改革示范区"
# if org == "山西转型综合改革示范区":
# org = "山西省转型综合改革示范区"
#
# # 校验参数完整性
# if not all([page, perpage]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# query = "" # 要查询的关键词
# args_term = dict() # 要匹配的字段
# args_cate = dict() # 要多字段(两导航)完全匹配
# args_org = dict() # 要多字段(两导航)完全匹配
#
# if keyword:
# query = keyword
# if category:
# args_term["category"] = category
# if org:
# args_org["org"] = org
# if year:
# args_term["year"] = year
# if level:
# args_term["level"] = level
#
# if inid:
# indu_name = Industry.query.filter_by(nid=inid).first().oname
# args_cate["indu"] = indu_name
#
# body = create_body(page, perpage, query, args_term, args_cate, args_org)
#
# try:
# # url = "http://127.0.0.1:9200/policy/_search"
# url = "http://127.0.0.1:9200/typolicy/_search"
# result_es = json.loads(requests.post(url=url, json=body).text)
# print(result_es)
# data = []
# size = result_es["hits"]["total"]
# for item in result_es["hits"]["hits"]:
# data.append({"name": item["_source"]["name"],
# "org": item["_source"]["org"],
# "pubdate": str(item["_source"]["pubdate"]),
# "id": item["_source"]["policyid"]})
# result = {"data": data, "size": size}
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
#
# return jsonify(code=RET.OK, msg="查询成功", data=result)
# 太原产业政策列表(转mysql)（pc更新）
@api_atlas.route('/industry/policyList', methods=['POST'])
# @login_required
def policy_list():
'''
:return:
'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
category = req_dict.get("category") # 政策类型
level = req_dict.get("level") # 发布级别
org = req_dict.get("org") # 发布机构
year = req_dict.get("year") # 发布年份
keyword = req_dict.get("keyword") # 搜索园区内容
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
if org == "省级":
org = "山西省政府"
if org == "市级":
org = "太原市政府"
if org == "区县":
org = "小店区政府"
if org == "开发区":
org = "山西转型综合改革示范区"
if org == "山西转型综合改革示范区":
org = "山西省转型综合改革示范区"
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
indu_policy = InduPolicy.query.order_by(InduPolicy.sorts_level)
# indu_policy = indu_policy.order_by(InduPolicy.sorts_level)
if category:
indu_policy = indu_policy.filter_by(category=category)
if org:
indu_policy = indu_policy.filter(InduPolicy.body.like("%{}%".format(org)))
if year:
indu_policy = indu_policy.filter_by(year=year)
if level:
indu_policy = indu_policy.filter_by(level=level)
if inid:
indu_name = Industry.query.filter_by(nid=inid).first().oname
indu_policy = indu_policy.filter(or_(InduPolicy.navigat.like("%{}%".format(indu_name)),
InduPolicy.navigator.like("%{}%".format(indu_name))))
if keyword: # 如果搜索，全部搜索
indu_policy = InduPolicy.query.filter(InduPolicy.name.like("%{}%".format(keyword)))
else:
indu_policy = indu_policy
size = indu_policy.count()
indu_policy = indu_policy.order_by(InduPolicy.sorts).order_by(InduPolicy.pubdate.desc()).paginate(page,
perpage).items
data = [{"id": i.id,
"name": i.name,
"org": i.org,
"pubdate": str(i.pubdate)[:10]} for i in indu_policy]
result = {"data": data, "size": size}
return jsonify(code=RET.OK, msg="查询成功", data=result)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# # 产业政策详情(转es)
# @api_atlas.route('/indupolicy/detail', methods=['POST'])
# # @login_required
# def policy_detail():
# '''
# 产业政策详情(从es数据查询文件本地的路径)
# :return:
# '''
# req_dict = request.get_json()
# _id = req_dict.get("id") # 产业政策policyid
# # 校验参数完整性
# if not all([_id]):
# return jsonify(errno=RET.PARAMERR, errmsg="参数不完整")
# body = {"query":
# {"bool": {"must": [{"term": {"policyid": "{}".format(_id)}}],
# "must_not": [],
# "should": []}},
# "from": 0,
# "size": 50,
# "sort": [],
# "aggs": {},
# "_source": [
# "name", "org", "pubdate", "industry", "category",
# "district", "url", "file"
# ],
# }
# try:
# url = "http://127.0.0.1:9200/typolicy/_search"
# result_es = json.loads(requests.post(url=url, json=body).text)
# data = result_es["hits"]["hits"][0]["_source"]
# # 转换https
# # data["file"] = str(data["file"]).replace("http","https")
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(errno=RET.DBERR, errmsg="数据库查询错误")
''''''
# 政策详情
@api_atlas.route("/indupolicy/detail", methods=["POST"])
def policy_detail():
req_dic = request.get_json()
_id = req_dic.get("id")
if not _id:
return jsonify(code=RET.PARAMERR, msg="参数不全")
if _id == 129:
_id = 52
try:
policy = InduPolicy.query.get(_id)
data = {"name": policy.name,
"file": policy.file if policy.file else "-",
"category": policy.category if policy.category else "-",
"org": policy.org if policy.org else "-",
"industry": policy.industry if policy.industry else "-",
"district": policy.district if policy.district else "-",
"pubdate": str(policy.pubdate)[0:10] if policy.pubdate else "-",
"url": policy.url if policy.pubdate else "-",
"post_num": policy.post_num if policy.post_num else ""}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
apps/atlas/view_es_con.py 0 → 100644
import json
import requests
from flask import g, current_app, request, jsonify, session
from apps.atlas import api_atlas
from apps.util import login_required
from apps.utils.response_code import RET
from apps.utils.neo4j_conn import conn_neo4j
graph = conn_neo4j()
def deleteDuplicate(li):
'''
列表[字典]去重
:param li:
:return:
'''
temp_list = list(set([str(i) for i in li]))
li = [eval(i) for i in temp_list]
return li
def check(name):
'''
判断当前企业是否有上下游关系，True有、False无
:param name: 节点名
:return:
'''
Cypher = "match (n)-[r]->(m) WHERE m.name='{}' or n.name='{}' return r.type".format(name, name)
res = graph.run(Cypher).data()
res = list(set([i["r.type"] for i in res]))
if res.__contains__("上游行业") or res.__contains__("下游行业"):
return True
return False
# 根据企业查询产品
def body_by_companyName(company_name):
'''
:param company_name: 公司名
:return:
'''
body = {
"query": {
"bool": {
"must": [
{
"match": {
"company_name": "{}".format(company_name)
}
}
],
"must_not": [],
"should": []
}
},
"sort": [],
"aggs": {},
"_source": ["product"]
}
return body
# 根据产品查询企业
def body_by_products(product):
'''
:param company_name: 公司名
:return:
'''
body = {
"query": {
"bool": {
"must": [
{
"match": {
"product": "{}".format(product)
}
}
],
"must_not": [],
"should": []
}
},
"from": 0,
"size": 20, # 限制条数
"sort": [],
"aggs": {},
"_source": ["company_name", "lng", "lat"]
}
return body
def trans_formet(name, list_data):
'''
:param name: str 要转换的主题name
:param list_data: list 要转换的数据列表
:return:
'''
for i in range(len(list_data)):
if list_data[i]["bname"] != name:
if list_data[i]["r.type"] == "上游行业":
list_data[i] = {
"source": name,
"relation": "下游行业",
"target": "{}".format(
list_data[i]["bname"])}
elif list_data[i]["r.type"] == "下游行业":
list_data[i] = {
"source": name,
"relation": "上游行业",
"target": "{}".format(
list_data[i]["bname"])}
else:
list_data[i] = {"source": "{}".format(list_data[i]["bname"]),
"relation": "{}".format(list_data[i]["r.type"]),
"target": "{}".format(list_data[i]["sname"])}
return list_data
def findCenterProducts(name):
'''
查找中间产品
查询当前产品往上直到有上下游关系，并返回产品实体名称和关系名称的列表
:param name: 产品名
:return:
'''
if check(name): # 直接关联上下游
res = [name]
return res
else:
sql = "match (n)-[r]->(m) WHERE m.name='{}' return n.name,r.type".format(name)
# print(sql)
res = graph.run(sql).data()
final_result = [] # 最终产品集
for i in res:
if check(i["n.name"]): # 判断是否有上下游关系(添加到最终产品集)
final_result.append(i["n.name"])
else:
result = findCenterProducts(i["n.name"])
final_result.extend(result)
if len(final_result) >= 1:
return final_result
else:
return []
def offer_company(name):
'''
# 判断是否有供应商
:param name: 产品实体
:return:
'''
try:
url = "http://127.0.0.1:9200/tychain/_search" # 产品对企业
# 1、根据公司查询产品
body = body_by_products(name)
result_es = json.loads(requests.post(url=url, json=body).text)
if result_es["hits"]["total"] >= 1:
return True
return False
except Exception as e:
current_app.logger.error(e)
return False
def findUpDownCompany(name_query, name): # 对中间产品进行上下游产品查询
'''
:param name_query: 要查询的产品
:param name: 中间产品
:return:
'''
sql_all = "match (n) -[r:`下游行业`]->(m) WHERE n.name='{}' return n.name as bname,r.type,m.name as sname UNION " \
"match (n) -[r:`上游行业`]->(m) WHERE m.name='{}' return n.name as bname,r.type,m.name as sname UNION " \
"match (n) -[r:`上游行业`]->(m) WHERE n.name='{}' return n.name as bname,r.type,m.name as sname UNION " \
"match (n) -[r:`下游行业`]->(m) WHERE m.name='{}' return n.name as bname,r.type,m.name as sname ".format(
name, name, name, name)
res_product = graph.run(sql_all).data()
res_product = trans_formet(name, res_product)
nodes = []
links = []
# nodes.append({"id": "{}".format(item), "name": "{}↓".format(item), "category": "2"})
# links.append({"from": "a", "to": "{}".format(item), "text": "产品"})
for i in res_product:
if offer_company(i["target"]): # 判断是否有供应商
nodes.append({"id": "{}".format(i["target"]), "name": "{}↓".format(i["target"]), "category": "3"})
links.append(
{"from": "{}".format(name_query), "to": "{}".format(i["target"]), "text": "{}".format(i["relation"])})
# if i["relation"] == "上游行业":
# if i["source"] == name_query:
# nodes.append({"name": "{}↓".format(i["target"]), "category": 3, "name_query": "{}".format(i["target"]), "isclick": 0})
# links.append({"source": "{}↓".format(i["source"]), "target": "{}↓".format(i["target"]), "name": "{}".format(i["relation"])})
# else:
# nodes.append({"name": "{}↓".format(i["target"]), "category": 3, "name_query": "{}".format(i["target"]), "isclick": 0})
# links.append({"source": "{}↓".format(name_query), "target": "{}↓".format( i["target"]), "name": "{}".format(i["relation"])})
# elif i["relation"] == "下游行业":
# nodes.append({"id": "{}".format(i["target"]), "name": "{}↓".format(i["target"]), "category": "3"})
# links.append({"from": "{}".format(name_query), "to": "{}".format(i["target"]),"text": "{}".format(i["relation"])})
# if i["source"] == name_query:
# nodes.append({"name": "{}↓".format(i["target"]), "category": 4, "name_query": "{}".format(i["target"]), "isclick": 0})
# links.append({"source": "{}↓".format(i["source"]), "target": "{}↓".format(i["target"]), "name": "{}".format(i["relation"])})
# else:
# nodes.append({"name": "{}↓".format(i["target"]), "category": 4, "name_query": "{}".format(i["target"]), "isclick": 0})
# links.append({"source": "{}↓".format(name_query), "target": "{}↓".format(i["target"]), "name": "{}".format(i["relation"])})
else:
nodes.append({"id": "{}".format(i["target"]), "name": "{}".format(i["target"]), "category": "3"})
links.append(
{"from": "{}".format(name_query), "to": "{}".format(i["target"]), "text": "{}".format(i["relation"])})
# if i["relation"] == "上游行业":
# if i["source"] == name_query:
# nodes.append({"name": "{}".format(i["target"]), "category": 3, "name_query": "{}".format(i["target"]), "isclick": 0})
# links.append({"source": "{}↓".format(i["source"]), "target": "{}".format(i["target"]), "name": "{}".format(i["relation"])})
# else:
# nodes.append({"name": "{}".format(i["target"]), "category": 3, "name_query": "{}".format(i["target"]), "isclick": 0})
# links.append({"source": "{}↓".format(name_query), "target": "{}".format(i["target"]), "name": "{}".format(i["relation"])})
# elif i["relation"] == "下游行业":
# if i["source"] == name_query:
# nodes.append({"name": "{}".format(i["target"]), "category": 4, "name_query": "{}".format(i["target"]), "isclick": 0})
# links.append({"source": "{}↓".format(i["source"]), "target": "{}".format(i["target"]), "name": "{}".format(i["relation"])})
# else:
# nodes.append({"name": "{}".format(i["target"]), "category": 4, "name_query": "{}".format(i["target"]), "isclick": 0})
# links.append({"source": "{}↓".format(name_query), "target": "{}".format(i["target"]), "name": "{}".format(i["relation"])})
return nodes, links
def findUDP(name): # 对中间产品进行上下游产品查询
'''
:param name_query: 要查询的产品
:param name: 中间产品
:return:
'''
sql_all = "match (n) -[r:`下游行业`]->(m) WHERE n.name='{}' return n.name as bname,r.type,m.name as sname UNION " \
"match (n) -[r:`上游行业`]->(m) WHERE m.name='{}' return n.name as bname,r.type,m.name as sname UNION " \
"match (n) -[r:`上游行业`]->(m) WHERE n.name='{}' return n.name as bname,r.type,m.name as sname UNION " \
"match (n) -[r:`下游行业`]->(m) WHERE m.name='{}' return n.name as bname,r.type,m.name as sname ".format(
name, name, name, name)
res_product = graph.run(sql_all).data()
res_product = trans_formet(name, res_product)
products = list()
for i in res_product:
products.append(i["target"])
return products
@api_atlas.route("/find_zero", methods=['POST'])
def find_zero():
try:
get_data = request.get_json()
name = get_data.get('company_name')
result = {
"nodes": [{"id": "a", "name": "{}↓".format(name), "category": "1"}],
"links": [],
"rootId": 'a'
}
return jsonify(code=RET.OK, msg="获取成功", data=result)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常", data={})
@api_atlas.route("/find_next", methods=['POST'])
def find_next():
req_dict = request.get_json()
name = req_dict.get('name') # 名称
# id = req_dict.get("id") # id
category = req_dict.get("category")
# 检查参数的完整性
if not all([name, category]):
return jsonify(code=RET.DATAERR, msg="参数不完整")
try:
if category == "1": # 查询企业的产品
url = "http://localhost:9200/ty_com2product/_search" # 产品对企业
# 1、根据公司查询产品
body = body_by_companyName(name)
result_es = json.loads(requests.post(url=url, json=body).text)
res = list(set([i["_source"]["product"] for i in result_es["hits"]["hits"]]))
if res:
nodes = list()
links = list()
result = dict()
products = list(set(res))
for item in products:
nodes.append({"id": "{}".format(item), "name": "{}↓".format(item), "category": "2"})
links.append({"from": "a", "to": "{}".format(item), "text": "产品"})
result["nodes"] = nodes
result["links"] = links
return jsonify(code=RET.OK, msg="获取成功", data=result)
else:
return jsonify(code=RET.NODATA, msg="无数据", data={})
elif category == "2": # 根据产品查询上下游产品
nodes = list()
links = list()
center_product = findCenterProducts(name) # 获取中间产品
for udp in center_product:
# findUpDownCompany(udp) # 获取上下游行业
antity, relation = findUpDownCompany(name, udp) # 获取上下游行业
nodes.extend(antity)
links.extend(relation)
nodes = deleteDuplicate(nodes)
links = deleteDuplicate(links)
result = {
"nodes": nodes,
"links": links
}
return jsonify(code=RET.OK, msg="获取成功", data=result)
elif category == "3": # 产品查询供应商
url = "http://localhost:9200/ty_com2product/_search"
body = body_by_products(name)
companys_return = json.loads(requests.post(url=url, json=body).text)
res = [i["_source"]["company_name"] for i in companys_return["hits"]["hits"]]
if res:
nodes = list()
links = list()
result = dict()
products = list(set(res))
for item in products:
nodes.append({"id": "{}".format(item), "name": "{}".format(item), "category": "4"})
links.append({"from": "{}".format(name), "to": "{}".format(item), "text": "{}".format("供应商企业")})
result["nodes"] = nodes
result["links"] = links
return jsonify(code=RET.OK, msg="获取成功", data=result)
else:
return jsonify(code=RET.NODATA, msg="无数据")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常", data={})
# 企业供应链地图
@api_atlas.route("/get_semic_map", methods=['POST'])
def get_semic_map():
try:
res = request.get_json()
company_name = res.get('company_name').strip()
c_type = res.get('c_type')
url = "http://localhost:9200/ty_com2product/_search" # 产品对企业
# 1、根据公司查询产品
body = body_by_companyName(company_name)
result_es = json.loads(requests.post(url=url, json=body).text)
products = list(set([i["_source"]["product"] for i in result_es["hits"]["hits"]])) # 无需去重，最终数据不会出现重复项
# print("直接产品:", products)
# 2、查询上下游产品
products_center = list()
for i in products:
products_center.extend(findCenterProducts(i))
products_uad = list()
for j in products_center:
products_uad.extend(findUDP(j))
products_uad = list(set(products_uad))
# print("中间产品：", products_uad)
# 3、根据产品进行供应商及其经纬度查询
companys = list()
for pro in products_uad:
body = body_by_products(pro)
companys_return = json.loads(requests.post(url=url, json=body).text)
companys.extend([i["_source"] for i in companys_return["hits"]["hits"]])
data = list()
if companys:
for item in companys:
data.append({"name": item["company_name"],
"jwd": {"lng": item["lng"], # 园区地址出的经纬度
"lat": item["lat"]}
})
return jsonify(code=RET.OK, msg="获取成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.PARAMERR, msg="参数错误")
apps/atlas/view_graph.py 0 → 100644
from flask import current_app, request, jsonify
from apps.atlas import api_atlas
from apps.util import login_required
from apps.utils.response_code import RET
from apps.models import *
from apps.utils.neo4j_conn import conn_neo4j,neo4j_dict
from apps import redis_store
import json
graph = conn_neo4j()
'''行业名转换ptp字典两个 neo4j_dict line 164/177'''
def deleteDuplicate(li):
'''
列表[字典]去重
:param li:
:return:
'''
temp_list = list(set([str(i) for i in li]))
li = [eval(i) for i in temp_list]
return li
def find_up(inid, name_query, relation, district):
if relation == "中游行业":
relation_c = "下位产品"
else:
relation_c = relation
sql = "match (n) -[r:`{}`]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(relation_c, name_query)
res = graph.run(sql).data()
cnums = Company.query.filter_by(stream="{}".format(relation[:2]), c_type=inid).count()
data = {"clickable": False,
"node": "{}".format(relation[:2]),
"level": 1,
"subNodeList": [],
"count": cnums
}
past = list()
for it in res:
productName = it["m.name"]
if productName in past:
continue
past.append(productName)
if district:
erjicount = Company.query.filter_by(province="山西省", city="太原市", district=district).filter(
Company.product_all.like("%{}%".format(productName))).count()
else:
erjicount = Company.query.filter_by(province="山西省", city="太原市").filter(
Company.product_all.like("%{}%".format(productName))).count()
node = {"clickable": True,
"node": "{}".format(productName),
"level": 2,
"count": erjicount,
"subNodeList": []
}
sql_02 = "match (n) -[r]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(productName)
result = graph.run(sql_02).data()
for item in result:
productName = item["m.name"]
if district:
count = Company.query.filter_by(province="山西省", city="太原市", district=district).filter(
Company.product_all.like("%{}%".format(productName))).count()
else:
count = Company.query.filter_by(province="山西省", city="太原市").filter(
Company.product_all.like("%{}%".format(productName))).count()
# erjicount += count
node["subNodeList"].append({"clickable": True,
"node": "{}".format(productName),
"level": 3,
"count": count,
"subNodeList": []
})
# node["count"] = erjicount # 累计值
data["subNodeList"].append(node)
return data
def find_up_thr(inid, name_query, relation, district):
if relation == "中游行业":
relation_c = "下位产品"
else:
relation_c = relation
cnums = Company.query.filter_by(stream="{}".format(relation[:2]), c_type=inid).count() # 上中下游企业数目
# 零级，上中下三游
data = {"clickable": False,
"node": "{}".format(relation[:2]),
"level": 1,
"subNodeList": [],
"count": cnums
}
sql_01 = "match (n) -[r:`{}`]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(relation_c, name_query)
res_zero = graph.run(sql_01).data()
res_one = list(set([i["m.name"] for i in list(res_zero)])) # 不重复的一级节点
for it in res_one: # 一级节点
pname_one = it
# 获取当前子节点数量
if district:
erjicount = Company.query.filter_by(c_type=inid, province="山西省", city="太原市", district=district).filter(
Company.product_all.like("%{}%".format(pname_one))).count()
else:
erjicount = Company.query.filter_by(c_type=inid, province="山西省", city="太原市").filter(
Company.product_all.like("%{}%".format(pname_one))).count()
# 一级
node_one = {"clickable": True,
"node": "{}".format(pname_one),
"level": 2,
"count": erjicount,
"subNodeList": []
}
sql_02 = "match (n) -[r]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(pname_one)
result = graph.run(sql_02).data()
result = list(set([i["m.name"] for i in list(result)])) # 不重复的二级节点
for item in result:
pname_two = item
# 二级子节点数量
if district:
count2 = Company.query.filter_by(c_type=inid, province="山西省", city="太原市", district=district).filter(
Company.product_all.like("%{}%".format(pname_two))).count()
else:
count2 = Company.query.filter_by(c_type=inid, province="山西省", city="太原市").filter(
Company.product_all.like("%{}%".format(pname_two))).count()
# 二级
node_two = {"clickable": True,
"node": "{}".format(pname_two),
"level": 3,
"count": count2,
"subNodeList": []
}
sql_03 = "match (n) -[r]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(pname_two)
result3 = graph.run(sql_03).data()
result3 = list(set([i["m.name"] for i in list(result3)])) # 不重复的三级节点
for itm in result3:
pname_thr = itm
# 二级子节点数量
if district:
count3 = Company.query.filter_by(c_type=inid, province="山西省", city="太原市", district=district).filter(
Company.product_all.like("%{}%".format(pname_thr))).count()
else:
count3 = Company.query.filter_by(c_type=inid, province="山西省", city="太原市").filter(
Company.product_all.like("%{}%".format(pname_thr))).count()
# 三级
node_thr = {"clickable": True,
"node": "{}".format(pname_thr),
"level": 4,
"count": count3,
"subNodeList": []
}
node_two["subNodeList"].append(node_thr)
node_one["subNodeList"].append(node_two)
data["subNodeList"].append(node_one)
return data
# 行业产品公司数量(链图,根据地理位置)
@api_atlas.route('/industry/chain', methods=['POST'])
# @login_required
def industry_chain():
'''
行业id->行业链标题-》上中下游-》查询数值
:return:
'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 二级行业id（二级行业显示链图）
district = req_dict.get("district") # 区县
# 校验参数完整性
if not all([inid]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
name_query = "ty" + str(inid) + str(district)
if redis_store.get(name_query) is not None:
data = json.loads(redis_store.get(name_query))
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 行业使用名
industryName = Industry.query.filter_by(nid=inid).first().oname
ptp = neo4j_dict()
if industryName in ptp:
industryName = ptp[industryName]
# print(industryName)
result = {
"industryChain": industryName,
"nodeList": [find_up_thr(inid, industryName, "上游行业", district),
find_up_thr(inid, industryName, "中游行业", district),
find_up_thr(inid, industryName, "下游行业", district)]
}
# redis缓存
redis_store.set(name_query, json.dumps(result))
redis_store.expire(name_query, 30 * 24 * 3600)
print("redis")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", data=result)
# 太原市一级行业下的两级图谱展示
@api_atlas.route("/industry/nevigate", methods=["POST"])
# @login_required
def indu_nevigate():
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id,不为0
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
# print(inid, cate)
if cate != "1":
return jsonify(code=RET.DATAERR, msg="参数异常")
try:
indu = Industry.query.filter_by(nid=inid, statu=1).first()
if not indu:
return jsonify(code=RET.DATAERR, msg="参数异常")
name = indu.name # 显示名
# childs = Industry.query.filter_by(fid=indu.nid, statu=1).all()
childs = Industry.query.filter_by(fid=indu.nid).all() # 全部展示
nodes = []
links = []
for child in childs:
count = Company.query.filter_by(c_type=child.nid).count() # 当前行业在数据中的频
if count==0:
continue
nodes.append(
{"id": child.nid, "name": "{}".format(child.name + "({})".format(count)), "count": count,
"nodeShape": 0, "color": "#43a2f1", "cate": "2"})
links.append({"from": '{}'.format(indu.nid), "to": '{}'.format(child.nid), "text": ''})
# id += 1
count = Company.query.filter_by(f_type=indu.nid).count()
nodes.append({"id": "{}".format(indu.nid), "name": "{}".format(name), "count": count, "cate": "1"})
result = {'nodes': deleteDuplicate(nodes), 'links': deleteDuplicate(links), "rootId": '1'}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", data=result)
# 点击二级导航的行业产业链原点()
@api_atlas.route('/ej/zero', methods=['POST'])
# @login_required
def zero():
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
if cate != "2":
return jsonify(code=RET.DATAERR, msg="参数错误")
center = Industry.query.filter_by(nid=inid).first()
pname = center.oname # 获取可查询真名
ptp = neo4j_dict()
product = pname
if pname in ptp:
product = ptp[pname]
sql = "match (n) -[r:`下游行业`]->(m) WHERE n.name='{}' return id(n) as id,n.name as name UNION " \
"match (n) -[r:`上游行业`]->(m) WHERE n.name='{}' return id(n) as id,n.name as name UNION " \
"match (n) -[r:`下位产品`]->(m) WHERE n.name='{}' return id(n) as id,n.name as name ".format(product,
product,
product)
res = graph.run(sql).data()
try:
result = {
"rootId": '{}'.format(res[0]["id"]),
"nodes": [{"id": "{}".format(res[0]["id"]), "name": "{}↓".format(product)}],
"links": [] # {"from": '1', "to": '{}'.format(res[0]["id"]), "text": ''}
}
except:
result = {
"rootId": '{}'.format(res[0]["id"]),
"nodes": [{"id": "{}".format(res[0]["id"]), "name": "{}↓".format(product)}],
"links": [] # {"from": '1', "to": '{}'.format(res[0]["id"]), "text": ''}
}
return jsonify(code=RET.OK, msg="获取成功", data=result)
def haveNext(name):
'''
判断是否有下一级子节点
:param name: name of node
:return:
'''
sql = "match (n)-[r]->(m) WHERE n.name='{}' return r.type limit 1".format(name)
res = graph.run(sql).data()
if len(res) >= 1:
return True
else:
return False
def find_next(name, _id):
'''
查找下一级节点
:param name:
:param _id: 出发节点id
:return:
'''
result = {'nodes': [], 'links': []}
sql = "match (n) -[r:`下游行业`]->(m) WHERE n.name='{}' return id(n),id(m),n.name,r.type,m.name UNION " \
"match (n) -[r:`上游行业`]->(m) WHERE n.name='{}' return id(n),id(m),n.name,r.type,m.name UNION " \
"match (n) -[r:`下位产品`]->(m) WHERE n.name='{}' return id(n),id(m),n.name,r.type,m.name ".format(name, name,
name)
res = graph.run(sql).data()
# print("查询结果：", res)
for i in res:
if haveNext(i["m.name"]):
result["nodes"].append({"id": "{}".format(i["id(m)"]), "name": "{}↓".format(i["m.name"])})
result["links"].append(
{"from": "{}".format(_id), "to": "{}".format(i["id(m)"]), "text": "{}".format(i["r.type"])})
else:
result["nodes"].append({"id": "{}".format(i["id(m)"]), "name": "{}".format(i["m.name"])})
result["links"].append(
{"from": "{}".format(_id), "to": "{}".format(i["id(m)"]), "text": "{}".format(i["r.type"])})
# for i in res:
# if haveNext(i["m.name"]):
# result["antity"].append({'name': '{}'.format(i["m.name"]), 'name_query': '{}'.format(
# i["m.name"])})
# result["relation"].append(
# {'source': '{}'.format(i["n.name"]), 'target': '{}↓'.format(i["m.name"]),
# 'name': '{}'.format(i["r.type"])})
# else:
# result["antity"].append({'name': '{}'.format(i["m.name"]), 'name_query': '{}'.format(
# i["m.name"])})
# result["relation"].append(
# {'source': '{}'.format(i["n.name"]), 'target': '{}'.format(i["m.name"]),
# 'name': '{}'.format(i["r.type"])})
# return result
return result
# 点击二级导航下行业产业链气泡出现下一级
@api_atlas.route('/ej/next', methods=['POST'])
# @login_required
def next():
req_dict = request.get_json()
name = req_dict.get("name") # 获取节点名称(不带下箭头)
# name_query = req_dict.get("name_query") # 获取查询节点名称
_id = req_dict.get("id") # 节点id
# 校验参数完整性
if not all([name]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
result = find_next(name, _id)
final_result = dict()
# 列表字典去重
nodes = deleteDuplicate(result["nodes"])
links = deleteDuplicate(result["links"])
final_result["nodes"] = nodes
final_result["links"] = links
return jsonify(code=RET.OK, msg="获取成功", data=final_result)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常", data={})
apps/attract/__init__.py 0 → 100644
from flask import Blueprint
# 创建蓝图对象
api_att = Blueprint("api_att", __name__)
from . import view
'''招商地图页'''
apps/attract/view.py 0 → 100644
from flask import g, current_app, request, jsonify, session
from apps.attract import api_att
from apps.util import login_required, verify_token
from apps.utils.response_code import RET
from apps.models import *
from apps.utils.neo4j_conn import conn_neo4j, neo4j_dict
import json
import requests
from apps import db, constants, redis_store
'''本页接口使用全国企业库enterprise'''
graph = conn_neo4j()
# 全国企业条件选择导航(类型，资质，上市，融资)
@api_att.route('/attract/field', methods=['GET'])
@login_required
def field():
'''太原市企业条件选择导航获取'''
try:
property = Property.query.filter_by(statu=1)
typy = property.filter_by(sid=1, statu=1).all()
qualificat = property.filter_by(sid=2, statu=1).all()
quoted = property.filter_by(sid=3, statu=1).all()
financ = property.filter_by(sid=4, statu=1).all()
data = {"entype": [{"label": i.name, "value": i.nid} for i in typy],
"qualificat": [{"label": i.name, "value": i.nid} for i in qualificat],
"quoted": [{"label": i.name, "value": i.nid} for i in quoted],
"financ": [{"label": i.name, "value": i.nid} for i in financ],
"buildate": [{"label": "1-3年", "value": 1}, {"label": "3-5年", "value": 2},
{"label": "5-8年", "value": 3}, {"label": "8-10年", "value": 4},
{"label": "10-15年", "value": 5}, {"label": "15年以上", "value": 6}],
"capital": [{"label": "100万以内", "value": 1}, {"label": "100万-500万", "value": 2},
{"label": "500万-1000万", "value": 3}, {"label": "1000万-5000万", "value": 4},
{"label": "5000万-1亿", "value": 5}, {"label": "1亿以上", "value": 6}]
}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", options=data)
# 全国企业列表
@api_att.route('/attract/enterprise', methods=['POST'])
# @login_required
def enterprise():
'''
太原市企业列表
:return:
'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
entype = req_dict.get("entype") # 企业类型id
qualificat = req_dict.get("qualificat") # 企业资质id
capital = req_dict.get("capital") # 注册资本id
quoted = req_dict.get("quoted") # 上市板块
area = req_dict.get("area") # ["省","市","区"]
province = area[0]
city = area[1]
district = area[2]
yearid = req_dict.get("yearid") # 成立时间年限id
roundid = req_dict.get("roundid") # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
product = req_dict.get("product") # 产业产品选择
company_name = req_dict.get("company_name") # 产业产品名称筛选
sorts = req_dict.get("sorts") # 排序 sorts "1"按时间降序 ，“2”按热度降序
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid: # 子行业分类
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
# 企业类型
if entype:
enterprise = enterprise.filter_by(entypeid=entype)
# 企业资质
if qualificat:
if qualificat == 1:
enterprise = enterprise.filter_by(high_new=1)
if qualificat == 2:
enterprise = enterprise.filter_by(tbe=1)
if qualificat == 3:
enterprise = enterprise.filter_by(quoted_company=1)
if qualificat == 4:
enterprise = enterprise.filter_by(isfive=1)
if qualificat == 5:
enterprise = enterprise.filter_by(unicorn=1)
if qualificat == 6:
enterprise = enterprise.filter_by(dengl=1)
# 注册资本
if capital:
enterprise = enterprise.filter_by(capital_id=capital)
# 上市板块
if quoted:
enterprise = enterprise.filter_by(public_id=quoted)
# 区域选择
if province:
enterprise = enterprise.filter_by(province=province)
if city:
enterprise = enterprise.filter_by(city=city)
if district:
enterprise = enterprise.filter_by(district=district)
# 成立时间id
if yearid:
enterprise = enterprise.filter_by(yearid=yearid)
# 融资轮次
if roundid:
enterprise = enterprise.filter_by(roundid=roundid)
if product:
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
# enterprise = enterprise.filter(Enterprise.product_all.ilike())
if company_name:
enterprise = enterprise.filter(Enterprise.company_name.like("%{}%".format(company_name)))
# print(enterprise)
size = enterprise.count()
if sorts=="1":
enterprise = enterprise.order_by(Enterprise.build_date.desc()).paginate(page, perpage).items # 企业热度倒序
else:
enterprise = enterprise.order_by(Enterprise.hots.desc()).paginate(page, perpage).items # 企业热度倒序
df = [{"id": i.id,
"company_name": i.company_name,
"hots": i.hots} for i in enterprise]
data = {"size": size, "df": df}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 通过like查询
def find_up(name_query, relation, area):
if relation == "中游行业":
relation_c = "下位产品"
else:
relation_c = relation
sql = "match (n) -[r:`{}`]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(relation_c, name_query)
res = graph.run(sql).data()
# cnums = Enterprise.query.filter_by(stream="{}".format(relation[:2]), c_type=inid).count()
data = {"clickable": False,
"node": "{}".format(relation[:2]),
"level": 1,
"subNodeList": [],
# "count": cnums
}
past = list()
for it in res:
productName = it["m.name"]
if productName in past:
continue
past.append(productName)
if area[0]:
enterprise = Enterprise.query.filter_by(province=area[0])
if area[1]:
enterprise = enterprise.filter_by(city=area[1])
if area[2]:
enterprise = enterprise.filter_by(district=area[2])
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(productName)))
else:
enterprise = Enterprise.query.filter(Enterprise.product_all.like("%{}%".format(productName)))
erjicount = enterprise.count()
node = {"clickable": True,
"node": "{}".format(productName),
"level": 2,
"count": erjicount,
"subNodeList": []
}
sql_02 = "match (n) -[r]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(productName)
result = graph.run(sql_02).data()
for item in result:
productName = item["m.name"]
if area[0]:
enterprise = Enterprise.query.filter_by(province=area[0])
if area[1]:
enterprise = enterprise.filter_by(city=area[1])
if area[2]:
enterprise = enterprise.filter_by(district=area[2])
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(productName)))
else:
enterprise = Enterprise.query.filter(Enterprise.product_all.like("%{}%".format(productName)))
count = enterprise.count()
erjicount += count
node["subNodeList"].append({"clickable": True,
"node": "{}".format(productName),
"level": 3,
"count": count,
"subNodeList": []
})
node["count"] = erjicount
data["subNodeList"].append(node)
return data
# 创建body
def create_body(args_query, args_term):
body = {
"query": {
"bool": {
"must": [{"multi_match": {"query": "{}".format(args_query["query"]), # match_phrase来实现完全匹配查询。
"type": "phrase",
"fields": [
"product"
],
"slop": 0,
}
},
]
}
},
"from": 0,
"size": 10,
"sort": [],
"aggs": {},
"_source": ['company_name'],
}
for k, v in args_term.items():
body["query"]["bool"]["must"].append({"term": {"{}".format(k): "{}".format(v)}})
return body
# 通过es全匹配查询
def find_up_by_es(name_query, relation, area):
if relation == "中游行业":
relation_c = "下位产品"
else:
relation_c = relation
args_term = dict() # 省市区条件
if area[0]:
args_term['province'] = area[0]
if area[1]:
args_term['city'] = area[1]
if area[2]:
args_term['district'] = area[2]
url = "http://127.0.0.1:9200/ty_cur/_search"
sql = "match (n) -[r:`{}`]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(relation_c, name_query)
res = graph.run(sql).data()
res = list(set([i["m.name"] for i in list(res)])) # 不重复的一级节点
data = {"clickable": False,
"node": "{}".format(relation[:2]),
"level": 1,
"subNodeList": [],
# "count": cnums
}
for it in res:
productName = it
# es全匹配查询企业数量
args_query = dict() # 产品
args_query["query"] = productName
body = create_body(args_query, args_term)
result_es = json.loads(requests.post(url=url, json=body).text)
erjicount = int(result_es["hits"]["total"])
node = {"clickable": True,
"node": "{}".format(productName),
"level": 2,
"count": erjicount,
"subNodeList": []
}
sql_02 = "match (n) -[r]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(productName)
result = graph.run(sql_02).data()
for item in result:
productName = item["m.name"]
# es全匹配查询企业数量
args_query = dict() # 产品
args_query["query"] = productName
body = create_body(args_query, args_term)
result_es = json.loads(requests.post(url=url, json=body).text)
count = int(result_es["hits"]["total"])
erjicount += count
node["subNodeList"].append({"clickable": True,
"node": "{}".format(productName),
"level": 3,
"count": count,
"subNodeList": []
})
node["count"] = erjicount
data["subNodeList"].append(node)
return data
# 通过es全匹配查询三级
def find_thr_by_es(inid, name_query, relation, area):
if relation == "中游行业":
relation_c = "下位产品"
else:
relation_c = relation
args_term = dict() # 省市区条件
if area[0]:
args_term['province'] = area[0]
if area[1]:
args_term['city'] = area[1]
if area[2]:
args_term['district'] = area[2]
args_term['c_type'] = inid # 指定二级企业分类
# url = "http://127.0.0.1:9200/ty_cur/_search"
# url = "http://127.0.0.1:9200/ty_all_enterprise/_search"
url = "http://127.0.0.1:9200/ty_enterprise/_search"
sql_01 = "match (n) -[r:`{}`]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(relation_c, name_query)
res_zero = graph.run(sql_01).data()
res_one = list(set([i["m.name"] for i in list(res_zero)])) # 不重复的一级节点
data = {"clickable": False,
"node": "{}".format(relation[:2]),
"level": 1,
"subNodeList": [],
# "count": cnums
}
for it in res_one:
pname_one = it
# es全匹配查询企业数量
args_query = dict() # 产品
args_query["query"] = pname_one
body = create_body(args_query, args_term)
result_es = json.loads(requests.post(url=url, json=body).text)
erjicount = int(result_es["hits"]["total"])
node_one = {"clickable": True,
"node": "{}".format(pname_one),
"level": 2,
"count": erjicount,
"subNodeList": []
}
sql_02 = "match (n) -[r]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(pname_one)
result = graph.run(sql_02).data()
result = list(set([i["m.name"] for i in list(result)])) # 不重复的二级节点
for item in result:
pname_two = item
# es全匹配查询企业数量
args_query = dict() # 产品
args_query["query"] = pname_two
body = create_body(args_query, args_term)
result_es = json.loads(requests.post(url=url, json=body).text)
count2 = int(result_es["hits"]["total"])
# 二级节点
node_two = {"clickable": True,
"node": "{}".format(pname_two),
"level": 3,
"count": count2,
"subNodeList": []
}
sql_03 = "match (n) -[r]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(pname_two)
result3 = graph.run(sql_03).data()
result3 = list(set([i["m.name"] for i in list(result3)])) # 不重复的三级节点
for itm in result3:
pname_thr = itm
args_query = dict() # 产品
args_query["query"] = pname_thr
body = create_body(args_query, args_term)
result_es = json.loads(requests.post(url=url, json=body).text)
count3 = int(result_es["hits"]["total"])
# 三级
node_thr = {"clickable": True,
"node": "{}".format(pname_thr),
"level": 4,
"count": count3,
"subNodeList": []
}
node_two["subNodeList"].append(node_thr)
node_one["subNodeList"].append(node_two)
data["subNodeList"].append(node_one)
return data
# 行业产品公司数量(链图)
@api_att.route('/attract/chain', methods=['POST'])
# @login_required
def attract_chain():
'''行业id->行业链标题-》上中下游-》查询数值'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 二级行业id（二级行业显示链图）
area = req_dict.get("area") # ["","",""] 省市区
# 校验参数完整性
if not all([inid]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
name_query = "att" + str(inid) + str("".join(area))
if redis_store.get(name_query) is not None:
data = json.loads(redis_store.get(name_query))
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 行业使用名
industryName = Industry.query.filter_by(nid=inid).first().oname
ptp = neo4j_dict()
if industryName in ptp:
industryName = ptp[industryName]
result = {
"industryChain": industryName,
"nodeList": [find_thr_by_es(inid, industryName, "上游行业", area),
find_thr_by_es(inid, industryName, "中游行业", area),
find_thr_by_es(inid, industryName, "下游行业", area)]
}
# redis缓存
redis_store.set(name_query, json.dumps(result))
redis_store.expire(name_query, 30 * 24 * 3600)
print("redis")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", data=result)
# 颜色计数
def jishu(num):
if num >= 0 and num <= 50:
return "#72D4F1"
if num > 50 and num <= 100:
return "#00BAF6"
if num > 100 and num <= 200:
return "#4F9FFF"
if num > 200 and num <= 500:
return "#4265F6"
if num > 500 and num <= 1000:
return "#0052d6"
if num > 1000:
return "#0245AE"
# (112.56937550968271, 37.87982942385603)
# 招商地图下的色块图(同右侧得数量分布饼图)
@api_att.route('/attract/map', methods=['POST'])
# @login_required
def attract_map():
'''招商地图'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
entype = req_dict.get("entype") # 企业类型id
qualificat = req_dict.get("qualificat") # 企业资质id
capital = req_dict.get("capital") # 注册资本id
quoted = req_dict.get("quoted") # 上市板块
area = req_dict.get("area") # ["省","市","区"]
province = area[0]
city = area[1]
district = area[2]
yearid = req_dict.get("yearid") # 成立时间年限id
roundid = req_dict.get("roundid") # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
product = req_dict.get("product") # 产业产品选择
try:
if inid:
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
# 企业类型
if entype:
enterprise = enterprise.filter_by(entypeid=entype)
# 企业资质
if qualificat:
if qualificat == 1:
enterprise = enterprise.filter_by(high_new=1)
if qualificat == 2:
enterprise = enterprise.filter_by(tbe=1)
if qualificat == 3:
enterprise = enterprise.filter_by(quoted_company=1)
if qualificat == 4:
enterprise = enterprise.filter_by(isfive=1)
if qualificat == 5:
enterprise = enterprise.filter_by(unicorn=1)
if qualificat == 6:
enterprise = enterprise.filter_by(dengl=1)
# 注册资本
if capital:
enterprise = enterprise.filter_by(capital_id=capital)
# 上市板块
if quoted:
enterprise = enterprise.filter_by(public_id=quoted)
# 成立时间id
if yearid:
enterprise = enterprise.filter_by(yearid=yearid)
# 融资轮次
if roundid:
enterprise = enterprise.filter_by(roundid=roundid)
if product:
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
# print(enterprise)
df = list()
if not province: # 全国，省数据
provinces = Enterprise.query.with_entities(Enterprise.province).distinct().all()
provinces = [i[0] for i in provinces if i[0]] # 拿到省份的无重复值
for pro in provinces:
num = enterprise.filter_by(province=pro).count()
province_data = Enterprise.query.filter_by(province=pro).first()
df.append({"name": pro,
"value": num,
"color": jishu(num),
"jwd": {"lng": province_data.p_lng, "lat": province_data.p_lat}})
return jsonify(code=RET.OK, msg="获取成功", data=df)
if province and not city: # 省-》市数据
cities = Enterprise.query.filter_by(province=province).with_entities(Enterprise.city).distinct().all()
cities = [i[0] for i in cities if i[0]] # 拿到城市的无重复值
for cit in cities:
num = enterprise.filter_by(province=province, city=cit).count()
city_data = Enterprise.query.filter_by(province=province, city=cit).first()
df.append({"name": cit,
"value": num,
"color": jishu(num),
"jwd": {"lng": city_data.c_lng, "lat": city_data.c_lat}})
return jsonify(code=RET.OK, msg="获取成功", data=df)
if province and city and not district: # 市-》区数据
districts = Enterprise.query.filter_by(province=province, city=city).with_entities(
Enterprise.district).distinct().all()
districts = [i[0] for i in districts if i[0]] # 拿到区县的无重复值
for dis in districts:
num = enterprise.filter_by(province=province, city=city, district=dis).count()
district_data = Enterprise.query.filter_by(province=province, city=city, district=dis).first()
df.append({"name": dis,
"value": num,
"color": jishu(num),
"jwd": {"lng": district_data.d_lng, "lat": district_data.d_lat}})
return jsonify(code=RET.OK, msg="获取成功", data=df)
if province and city and district: # 区数据
num = enterprise.filter_by(province=province, city=city, district=district).count()
district_data = Enterprise.query.filter_by(province=province, city=city, district=district).first()
df.append({"name": district,
"value": num,
"color": "",
"jwd": {"lng": district_data.d_lng, "lat": district_data.d_lat}})
return jsonify(code=RET.OK, msg="获取成功", data=df)
return jsonify(code=RET.DATAERR, msg="地区参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 为右侧全国地图企业数据
@api_att.route('/attract/cnums', methods=['POST'])
# @login_required
def attract_cnums():
'''招商地图'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
entype = req_dict.get("entype") # 企业类型id
qualificat = req_dict.get("qualificat") # 企业资质id
capital = req_dict.get("capital") # 注册资本id
quoted = req_dict.get("quoted") # 上市板块
area = req_dict.get("area") # ["省","市","区"]
province = area[0]
city = area[1]
district = area[2]
yearid = req_dict.get("yearid") # 成立时间年限id
roundid = req_dict.get("roundid") # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
product = req_dict.get("product") # 产业产品选择
try:
if inid:
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
# 企业类型
if entype:
enterprise = enterprise.filter_by(entypeid=entype)
# 企业资质
if qualificat:
if qualificat == 1:
enterprise = enterprise.filter_by(high_new=1)
if qualificat == 2:
enterprise = enterprise.filter_by(tbe=1)
if qualificat == 3:
enterprise = enterprise.filter_by(quoted_company=1)
if qualificat == 4:
enterprise = enterprise.filter_by(isfive=1)
if qualificat == 5:
enterprise = enterprise.filter_by(unicorn=1)
if qualificat == 6:
enterprise = enterprise.filter_by(dengl=1)
# 注册资本
if capital:
enterprise = enterprise.filter_by(capital_id=capital)
# 上市板块
if quoted:
enterprise = enterprise.filter_by(public_id=quoted)
# 成立时间id
if yearid:
enterprise = enterprise.filter_by(yearid=yearid)
# 融资轮次
if roundid:
enterprise = enterprise.filter_by(roundid=roundid)
if product:
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
# print(enterprise)
df = list()
if not province: # 全国，省数据
provinces = Enterprise.query.with_entities(Enterprise.province).distinct().all()
provinces = [i[0] for i in provinces if i[0]] # 拿到省份的无重复值
for pro in provinces:
num = enterprise.filter_by(province=pro).count()
df.append({"name": pro, "value": num})
df = sorted(df, key=lambda x: x["value"], reverse=True)
return jsonify(code=RET.OK, msg="获取成功", data=df[:5])
if province and not city: # 省-》市数据
cities = Enterprise.query.filter_by(province=province).with_entities(Enterprise.city).distinct().all()
cities = [i[0] for i in cities if i[0]] # 拿到城市的无重复值
for cit in cities:
num = enterprise.filter_by(province=province, city=cit).count()
df.append({"name": cit,"value": num})
df = sorted(df, key=lambda x: x["value"], reverse=True)
return jsonify(code=RET.OK, msg="获取成功", data=df[:5])
if province and city and not district: # 市-》区数据
districts = Enterprise.query.filter_by(province=province, city=city).with_entities(
Enterprise.district).distinct().all()
districts = [i[0] for i in districts if i[0]] # 拿到区县的无重复值
for dis in districts:
num = enterprise.filter_by(province=province, city=city, district=dis).count()
df.append({"name": dis,"value": num})
df = sorted(df, key=lambda x: x["value"], reverse=True)
return jsonify(code=RET.OK, msg="获取成功", data=df[:5])
if province and city and district: # 区数据
num = enterprise.filter_by(province=province, city=city, district=district).count()
df.append({"name": district,"value": num})
df = sorted(df, key=lambda x: x["value"], reverse=True)
return jsonify(code=RET.OK, msg="获取成功", data=df[:5])
return jsonify(code=RET.DATAERR, msg="地区参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 招商地图下的散点图（至区后）
@api_att.route('/attract/sdmap', methods=['POST'])
# @login_required
def attract_sdmap():
'''招商地图'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
entype = req_dict.get("entype") # 企业类型id
qualificat = req_dict.get("qualificat") # 企业资质id
capital = req_dict.get("capital") # 注册资本id
quoted = req_dict.get("quoted") # 上市板块
area = req_dict.get("area") # ["省","市","区"]
province = area[0]
city = area[1]
district = area[2]
yearid = req_dict.get("yearid") # 成立时间年限id
roundid = req_dict.get("roundid") # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
product = req_dict.get("product") # 产业产品选择
# 校验参数完整性
if not all([province, city, district]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid:
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
# 企业类型
if entype:
enterprise = enterprise.filter_by(entypeid=entype)
# 企业资质
if qualificat:
if qualificat == 1:
enterprise = enterprise.filter_by(high_new=1)
if qualificat == 2:
enterprise = enterprise.filter_by(tbe=1)
if qualificat == 3:
enterprise = enterprise.filter_by(quoted_company=1)
if qualificat == 4:
enterprise = enterprise.filter_by(isfive=1)
if qualificat == 5:
enterprise = enterprise.filter_by(unicorn=1)
if qualificat == 6:
enterprise = enterprise.filter_by(dengl=1)
# 注册资本
if capital:
enterprise = enterprise.filter_by(capital_id=capital)
# 上市板块
if quoted:
enterprise = enterprise.filter_by(public_id=quoted)
# 区域选择
if district:
# enterprise = enterprise.filter_by(district=district)
enterprise = enterprise.filter_by(province=province, city=city, district=district)
# 成立时间id
if yearid:
enterprise = enterprise.filter_by(yearid=yearid)
# 融资轮次
if roundid:
enterprise = enterprise.filter_by(roundid=roundid)
if product:
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
# enterprise = enterprise.filter_by(province=province, city=city, district=district).all()
enterprise = enterprise.all()
data = []
for com in enterprise:
data.append({"id": com.id,
"name": com.company_name,
"jwd": {"lng": com.lng, # 企业地址出的经纬度
"lat": com.lat}
}) # 上下中游
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 全国企业信息详情（已经启用，改用360页企业详情）
@api_att.route('/enterprise/detail', methods=['POST'])
@login_required
def enter_detail():
'''
企业信息详情
:return:
'''
# 获取用户id
token = request.headers["token"]
user = verify_token(token)
user_id = user.id # 用户id
req_dict = request.get_json()
_id = req_dict.get("id") # 企业id
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
company = Enterprise.query.get(_id)
user = User.query.get(user_id) # 获取关注列表
if user:
enters_ids = [coms.id for coms in user.enterprise]
else:
enters_ids = []
if company:
data = {"id": company.id,
"company_name": company.company_name,
"telephone": company.telephone if company.telephone else "-",
"web_site": company.web_site if company.web_site else "-",
"email": company.email if company.email else "-",
"address": company.address if company.address else "-",
"jwd": {"lng": company.lng if company.lng else "-",
"lat": company.lat if company.lat else "-"},
"company_info": company.company_info if company.company_info else "-",
"high_new": "高新技术企业" if company.high_new else "-",
"legal": company.legal if company.legal else "-",
"status": company.status if company.status else "-",
"build_date": str(company.build_date)[:10] if company.build_date else "-",
"capital": company.capital if company.capital else "-",
"social_code": company.social_code if company.social_code else "-",
"taking": company.takingn if company.takingn else "-",
"bao": company.bao_num if company.bao_num else "-",
"entype": company.entype if company.entype else "-",
"industry": company.company_industry if company.company_industry else "-",
"scope": company.business_scope if company.business_scope else "-",
"collect": "1" if company.id in enters_ids else "2", # 关注状态码1关注，2未关注
"choice": "2" # 1太原企业，2全国企业
}
else:
return jsonify(code=RET.NODATA, msg="查无数据")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
apps/constants.py 0 → 100644
# 专用于保存程序中用到的常量数据
# 图片验证码的有效期，单位：秒
IMAGE_CODE_REDIS_EXPIRES = 180
# 短信验证码的redis有效期, 单位：秒
SMS_CODE_REDIS_EXPIRES = 300
# 发送短信验证码的间隔, 单位：秒
SEND_SMS_CODE_INTERVAL = 60
# 发送邮箱验证码的间隔, 单位：秒
SEND_EMS_CODE_INTERVAL = 180
# 登录错误尝试次数
LOGIN_ERROR_TIMES = 5
# 登录错误限制事件，单位：秒
LOGIN_ERROR_FORBID_TIME = 900
# 用户上传图片或文件的保存，七牛云
UPLOAD_IMAGE_URL = ''
# 用户下载文件的保存，本地
UPLOAD_FILE_URL = 'http://127.0.0.1:5000/static/files/'
# 城区信息的缓存时间，单位：秒
AREA_INFO_REDIS_EXPIRE = 7200
# 首页显示的图片数量，单位：个
HOME_PAGE_INDEX_IMAGES = 10
# 首页信息的缓存时间，单位：秒
HOME_PAGE_REDIS_EXPIRE = 3600
# 详情信息的缓存时间，单位：秒
HOUSE_DETAIL_REDIS_EXPIRE = 3600
# 列表页面每页数据容量
HOUSE_LIST_PER_PAGE_CAPACITY = 2
# 列表页缓存的有效期，单位：秒
HOUSE_LIST_PAGE_REDIS_EXPIRE = 3600
# 详情页面显示的评论条目数
HOUSE_DETAIL_COMMENT_DISPLAY_COUNTS = 20
# 支付宝的网关地址
API_PAY_ADDRESS = "https://openapi.alipaydev.com/gateway.do?"
apps/inves_manage/__init__.py 0 → 100644
from flask import Blueprint
# pro_url = "http:127.0.0.1:5000/static"
pro_url = "http://touzi.cjwltzj.taiyuan.gov.cn/files/"
# 创建蓝图对象
api_manage = Blueprint("api_manage", __name__)
from . import view
from . import view_zone
from . import view_attract
"招商资源管理"
apps/inves_manage/view.py 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
apps/inves_manage/view_attract.py 0 → 100644
import os
from flask import g, current_app, request, jsonify, session, send_from_directory, make_response
from apps.inves_manage import api_manage
# from apps.utils.commons import login_required
from apps.util import login_required
from apps.utils.response_code import RET
from apps.models import *
from apps.utils.read_json import open_type
from datetime import datetime, timedelta
from sqlalchemy import extract, or_, and_
from sqlalchemy.sql import func
import datetime
import filetype
from apps.utils.forms import *
from werkzeug.datastructures import CombinedMultiDict
from apps.models import *
# 获取筛选条件
@api_manage.route("/attFiled", methods=["GET"])
@login_required
def att_filed():
user_id = g.user_id
try:
user = User.query.get(user_id)
unit = user.unit # 用户所在机构
goverment = Government.query.filter_by(name=unit).first() # 按名查找机构
sections = [i.name for i in goverment.sections] # 机构下部门
attract = Attract.query.filter_by(statu=1) # 招商字典
indu = attract.filter_by(sid=1).all() # 行业
stage = attract.filter_by(sid=2).all() # 阶段（进度）
data = {"indu": {i.name: i.nid for i in indu},
"capital": {"1亿以下": 1, "1-10亿": 2, "10-50亿": 3, "50-100亿": 4, "100亿以上": 5},
"stage": {i.name: i.nid for i in stage},
"section": sections
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
def pic(x):
if x < 0:
return False
if x <= 1:
return 1
if x <= 10:
return 2
if x <= 50:
return 3
if x <= 100:
return 4
return 5
# # 项目新增
# @api_manage.route("/addItem", methods=["GET"])
# @login_required
# def add_item():
# req_dict = request.get_json()
# company_name = req_dict.get("company_name") # 企业名称
# build_date = req_dict.get("build_date") # 成立时间
# admin = req_dict.get("admin") # 企业联系人
# mobile = req_dict.get("mobile") # 企业联系人联系方式
# email = req_dict.get("email") # 企业联系人邮箱
#
# name = req_dict.get("name") # 项目名称
# product = req_dict.get("product") # 项目产品
# industry = req_dict.get("industry") # 项目行业
# indu_id = req_dict.get("indu_id") # 项目行业
# invest = req_dict.get("invest") # 投资额
# # invest_id =
# area = req_dict.get("area") # 占地面积
# value = req_dict.get("value") # 预计产值
# tax = req_dict.get("tax") # 预计税收
# store = req_dict.get("store") # 项目入库时间
# unit_up = req_dict.get("store") # 项目入库时间
# link = req_dict.get("link") # 项目对接人
# link_mobile = req_dict.get("link_mobile") # 项目对接人联系方式
# level = req_dict.get("level") # 项目级别
# level_id = req_dict.get("level_id") # 项目级别id
# stage = req_dict.get("level") # 项目进度
# stage_id = req_dict.get("stage_id") # 项目进度id
#
# main_introduce = req_dic.get("main_introduce") # 项目主体介绍
# invest_introduce = req_dic.get("invest_introduce") # 投资项目介绍
# build_introduce = req_dic.get("build_introduce") # 项目建设内容
# encomy = req_dic.get("encomy") # 项目的经济效益
# policy = req_dic.get("policy") # 项目政策需求
# question = req_dic.get("question") # 项目存在的问题
# file = request.files.get("file") # 文件
apps/inves_manage/view_zone.bk 0 → 100644
import os
import json
from flask import g, current_app, request, jsonify, session, send_from_directory, make_response
from apps.inves_manage import api_manage, pro_url
# from apps.utils.commons import login_required
from apps.util import verify_token
from apps.util import login_required
from apps.utils.response_code import RET
from apps.models import *
from apps.utils.read_json import open_type
from datetime import datetime, timedelta
from sqlalchemy import extract, or_, and_
from sqlalchemy.sql import func
import datetime
import filetype
import time
from apps.utils.forms import *
from werkzeug.datastructures import CombinedMultiDict
# 获取筛选条件
@api_manage.route("/getFiled", methods=["GET"])
@login_required
def get_filed():
try:
zone = Zone.query.filter_by(statu=1)
cates = zone.filter_by(sid=1).all() # 类别
levels = zone.filter_by(sid=2).all() # 级别
# options: [{value: "选项1", label: "无数据"}, {value: "选项2", label: "3333"}],
data = {"cate": [{"label": i.name, "value": i.nid} for i in cates], # [i.name for i in cates],
"level": [{"label": i.name, "value": i.nid} for i in levels], # [i.name for i in levels],
"indu": [{"label": "高端装备", "value": 1}, {"label": "新材料", "value": 2},
{"label": "新一代信息技术", "value": 3}, {"label": "现代服务业", "value": 4}],
"status": [{"label": "未上报", "value": 1}, {"label": "审核通过", "value": 2},
{"label": "审核驳回", "value": 3}, {"label": "正在审核", "value": 4}]
}
data["cate"].insert(0, {"label": "请选择", "value": ""})
data["level"].insert(0, {"label": "请选择", "value": ""})
data["indu"].insert(0, {"label": "请选择", "value": ""})
data["status"].insert(0, {"label": "请选择", "value": ""})
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 获取园区列表（层级权限）
@api_manage.route("/listOfGarden", methods=["POST"])
@login_required
def list_garden():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.get_json()
key = req_dict.get("key")
indu = req_dict.get("indu")
level = req_dict.get("level")
cate = req_dict.get("cate")
status = req_dict.get("status")
page = req_dict.get("page")
perpage = req_dict.get("perpage")
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.get(user_id) # 获取当前用户
role = user.role # 获取角色
unit = user.unit # 用户机构
section = user.section # 用户部门
garden = Garden.query.filter_by()
# garden = garden.filter(Garden.cluster.like("%{}%".format(indu)))
if indu:
garden = garden.filter(Garden.cluster.like("%{}%".format(indu)))
if level:
garden = garden.filter_by(level=level)
if cate:
garden = garden.filter_by(cate=cate)
if status:
garden = garden.filter_by(status=status)
if key:
garden = garden.filter(Garden.name.like("%{}%".format(key)))
if role.role[0] == "1": # 机构领导（看全部）
maxnum = garden.filter(or_(Garden.unit == unit, Garden.up_unit == unit)).count()
gardens = garden.filter(or_(Garden.unit == unit, Garden.up_unit == unit)).paginate(page, perpage).items
data = [{"id": i.id,
"name": i.name,
"address": i.address,
"level": i.level,
"cate": i.cate,
"charge": i.charge,
"phone": i.phone,
"uperson": i.uperson if i.uperson else "",
"unit": i.up_unit,
"status": i.status if i.status else ""} for i in gardens]
data = {"data_lis":data,"maxnum":maxnum}
return jsonify(code=RET.OK, msg="查询成功", data=data)
if role.role[0] == "2": # 部门领导（看部门），自己部门，上报给自己机构的
# print("===========")
gardens = garden.filter(
or_(Garden.up_unit == unit, and_(Garden.unit == unit, Garden.section == section))).paginate(page,
perpage).items
maxnum = garden.filter(
or_(Garden.up_unit == unit, and_(Garden.unit == unit, Garden.section == section))).count()
# print(gardens)
data = [{"id": i.id,
"name": i.name,
"address": i.address,
"level": i.level,
"cate": i.cate,
"charge": i.charge,
"phone": i.phone,
"uperson": i.uperson if i.uperson else "",
"unit": i.up_unit,
"status": i.status if i.status else ""} for i in gardens]
data = {"data_lis": data, "maxnum": maxnum}
return jsonify(code=RET.OK, msg="查询成功", data=data)
if role.role[0] == "3": # 自己看自己,+上报给自己机构的
gardens = garden.filter(or_(Garden.user == user_id, Garden.up_unit == unit))
maxnum = gardens.count()
# print(gardens)
gardens = gardens.paginate(page, perpage).items
# print(gardens)
data = [{"id": i.id,
"name": i.name,
"address": i.address,
"level": i.level,
"cate": i.cate,
"charge": i.charge,
"phone": i.phone,
"uperson": i.uperson if i.uperson else "",
"unit": i.up_unit,
"status": i.status if i.status else ""} for i in gardens]
data = {"data_lis": data, "maxnum": maxnum}
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 园区新增
@api_manage.route("/addGarden", methods=["POST"])
@login_required
def add_garden():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
role = user.role.role
if not role:
return jsonify(code=RET.OK, msg="无权限查看此内容")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
role = user.role
if role.role[5] != "1":
return jsonify(code=RET.REQERR, msg="暂无权限")
req_dict = request.get_json()
name = req_dict.get("name") # 园区姓名
level = req_dict.get("level") # 园区级别
charge = req_dict.get("charge") # 园区负责人
phone = req_dict.get("phone") # 园区联系电话
cate = req_dict.get("cate") # 园区类型
address = req_dict.get("address") # 园区地址
cluster = req_dict.get("cluster") # 产业集群（多选）[]
# 园区信息
area = req_dict.get("area") # 占地面积(平方公里)
acreage = req_dict.get("acreage") # 规划面积（平方公里）
actarea = req_dict.get("actarea") # 建成面积（平方公里）
tax = req_dict.get("tax") # 税收要求（万元/亩）
out_power = req_dict.get("out_power") # 产出强度（万元/亩）
invest_power = req_dict.get("invest_power") # 投资强度（万元/亩）
indu_need = req_dict.get("indu_need") # 行业要求
gdp = req_dict.get("gdp") # GDP(亿元)
fiscal = req_dict.get("fiscal") # 财政收入（亿元）
indu_land = req_dict.get("indu_land") # 工业土地均价（万元/亩）
indu_sup = req_dict.get("indu_sup") # 工业土地供应量
comm_land = req_dict.get("comm_land") # 商办土地均价（万元/亩）
comm_sup = req_dict.get("comm_sup") # 商办土地供应量
represent = req_dict.get("represent") # 代表企业
# 投资成本
resident_ele_one = req_dict.get("resident_ele_one") # 居民用电（一档）（元/度）
resident_ele_two = req_dict.get("resident_ele_two") # 居民用电（二档）（元/度）
resident_ele_thr = req_dict.get("resident_ele_thr") # 居民用电（三档）（元/度）
comm_ele_one = req_dict.get("comm_ele_one") # 商业用电（峰段）（元/度）
comm_ele_two = req_dict.get("comm_ele_two") # 商业用电（平段）（元/度）
comm_ele_thr = req_dict.get("comm_ele_thr") # 商业用电（谷段）（元/度）
indu_ele_one = req_dict.get("indu_ele_one") # 工业用电（峰段）（元/度）
indu_ele_two = req_dict.get("indu_ele_two") # 工业用电（平段）（元/度）
indu_ele_thr = req_dict.get("indu_ele_thr") # 工业用电（谷段）（元/度）
resident_water_one = req_dict.get("resident_water_one") # 居民用水（一档）（元/吨）
resident_water_two = req_dict.get("resident_water_two") # 居民用水（二档）（元/吨）
resident_water_thr = req_dict.get("resident_water_thr") # 居民用水（三档）（元/吨）
comm_water = req_dict.get("comm_water") # 商业用水（元/吨）
indu_water = req_dict.get("indu_water") # 工业用水（元/吨）
special_water = req_dict.get("special_water") # 特种用水（元/吨）
resident_natgas_one = req_dict.get("resident_natgas_one") # 居民用气（一档）（元/m³）
resident_natgas_two = req_dict.get("resident_natgas_two") # 居民用气（二档）（元/m³）
resident_natgas_thr = req_dict.get("resident_natgas_thr") # 居民用气（三档）（元/m³）
sewage = req_dict.get("sewage") # 污水处理（元/吨）
wagelevel = req_dict.get("wagelevel") # 最低工资标准（元/月）
worker = req_dict.get("worker") # 普通员工（元/月）
middlemag = req_dict.get("middlemag") # 中级管理人员（元/月）
highmag = req_dict.get("highmag") # 高层管理人员（元/月）
# 环境配套
dis_freight = req_dict.get("dis_freight") # 距离货运站距离
dis_rail = req_dict.get("dis_rail") # 距离高铁站
dis_port = req_dict.get("dis_port") # 距离港口距离
dis_air = req_dict.get("dis_air") # 距离机场距离
road_trans = req_dict.get("road_trans") # 公路运输
rail_trans = req_dict.get("rail_trans") # 铁路运输
live_facility = req_dict.get("live_facility") # 园区生活配套
market = req_dict.get("market") # 百货商场
hotel_bus = req_dict.get("hotel_bus") # 酒店商务
medical = req_dict.get("medical") # 医疗机构
education = req_dict.get("education") # 学校教育
induenterprise = req_dict.get("induenterprise") # 规模以上企业
innovate = req_dict.get("innovate") # 科研机构
base = req_dict.get("base") # 双创基地
carrier = req_dict.get("carrier") # 产业载体
if not all([name, level, charge, phone, cate, address, cluster, area, acreage, actarea, tax, out_power,
invest_power, indu_land, indu_need, gdp, fiscal, indu_sup, comm_land, comm_sup, represent]):
return jsonify(code=RET.PARAMERR, msg="基本信息请填完整")
cluster = ",".join(cluster)
try:
user = User.query.get(user_id)
unit = user.unit
section = user.section
garden = Garden(unit=unit, section=section, user=user_id, name=name, level=level, charge=charge, phone=phone,
cate=cate, address=address, cluster=cluster, area=area, acreage=acreage, actarea=actarea,
tax=tax, out_power=out_power, invest_power=invest_power, indu_need=indu_need, gdp=gdp,
fiscal=fiscal, indu_land=indu_land, indu_sup=indu_sup, comm_land=comm_land, comm_sup=comm_sup,
represent=represent)
if resident_ele_one:
garden.resident_ele_one = resident_ele_one
if resident_ele_two:
garden.resident_ele_two = resident_ele_two
if resident_ele_thr:
garden.resident_ele_thr = resident_ele_thr
if comm_ele_one:
garden.comm_ele_one = comm_ele_one
if comm_ele_two:
garden.comm_ele_two = comm_ele_two
if comm_ele_thr:
garden.comm_ele_thr = comm_ele_thr
if indu_ele_one:
garden.indu_ele_one = indu_ele_one
if indu_ele_two:
garden.indu_ele_two = indu_ele_two
if indu_ele_thr:
garden.indu_ele_thr = indu_ele_thr
if resident_water_one:
garden.resident_water_one = resident_water_one
if resident_water_two:
garden.resident_water_two = resident_water_two
if resident_water_thr:
garden.resident_water_thr = resident_water_thr
if comm_water:
garden.comm_water = comm_water
if indu_water:
garden.indu_water = indu_water
if special_water:
garden.special_water = special_water
if resident_natgas_one:
garden.resident_natgas_one = resident_natgas_one
if resident_natgas_two:
garden.resident_natgas_two = resident_natgas_two
if resident_natgas_thr:
garden.resident_natgas_thr = resident_natgas_thr
if sewage:
garden.sewage = sewage
if wagelevel:
garden.wagelevel = wagelevel
if worker:
garden.worker = worker
if middlemag:
garden.middlemag = middlemag
if highmag:
garden.highmag = highmag
if dis_freight:
garden.dis_freight = dis_freight
if dis_rail:
garden.dis_rail = dis_rail
if dis_port:
garden.dis_port = dis_port
if dis_air:
garden.dis_air = dis_air
if road_trans:
garden.road_trans = road_trans
if rail_trans:
garden.rail_trans = rail_trans
if live_facility:
garden.live_facility = live_facility
if market:
garden.market = market
if hotel_bus:
garden.hotel_bus = hotel_bus
if medical:
garden.medical = medical
if education:
garden.education = education
if induenterprise:
garden.induenterprise = induenterprise
if innovate:
garden.innovate = innovate
if base:
garden.base = base
if carrier:
garden.carrier = carrier
db.session.add(garden)
db.session.commit()
garden_id = garden.id
return jsonify(code=RET.OK, msg="添加成功", id=garden_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 园区审核
@api_manage.route("/passGarden", methods=["POST"])
@login_required
def pass_garden():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
role = user.role
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
if role.role[4] != "1":
return jsonify(code=RET.REQERR, msg="暂无权限")
req_dict = request.get_json()
id = req_dict.get("id") # 园区id
advice = req_dict.get("advice") # 1通过，2驳回
if not all([id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
garden = Garden.query.get(id)
if advice == 1:
garden.status = "审核通过"
db.session.commit()
return jsonify(code=RET.OK, msg="已通过")
else:
garden.status = "审核驳回"
db.session.commit()
return jsonify(code=RET.OK, msg="已驳回")
except Exception as e:
db.session.rollabck()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 园区上报
@api_manage.route("/sendGarden", methods=["POST"])
@login_required
def send_garden():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
role = user.role
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
if role.role[4] != "1":
return jsonify(code=RET.REQERR, msg="暂无权限")
req_dict = request.get_json()
id = req_dict.get("id") # 园区id
org = req_dict.get("org") # 待上报机构名
if not all([id, org]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
garden = Garden.query.get(id)
garden.uperson = user.name
garden.up_unit = org
garden.status = "正在审核"
db.session.commit()
return jsonify(code=RET.OK, msg="上报成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 园区修改
@api_manage.route("/editGarden", methods=["POST"])
@login_required
def edit_garden():
# user_id = g.user_id
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
user = User.query.get(user_id)
role = user.role
if role.role[5] != "1":
return jsonify(code=RET.REQERR, msg="暂无权限")
req_dict = request.get_json()
id = req_dict.get("id") # 园区id
name = req_dict.get("name") # 园区姓名
level = req_dict.get("level") # 园区级别
charge = req_dict.get("charge") # 园区负责人
phone = req_dict.get("phone") # 园区联系电话
cate = req_dict.get("cate") # 园区类型
address = req_dict.get("address") # 园区地址
cluster = req_dict.get("cluster") # 产业集群（多选）
# 园区信息
area = req_dict.get("area") # 占地面积(平方公里)
acreage = req_dict.get("acreage") # 规划面积（平方公里）
actarea = req_dict.get("actarea") # 建成面积（平方公里）
tax = req_dict.get("tax") # 税收要求（万元/亩）
out_power = req_dict.get("out_power") # 产出强度（万元/亩）
invest_power = req_dict.get("invest_power") # 投资强度（万元/亩）
indu_need = req_dict.get("indu_need") # 行业要求
gdp = req_dict.get("gdp") # GDP(亿元)
fiscal = req_dict.get("fiscal") # 财政收入（亿元）
indu_land = req_dict.get("indu_land") # 工业土地均价（万元/亩）
indu_sup = req_dict.get("indu_sup") # 工业土地供应量
comm_land = req_dict.get("comm_land") # 商办土地均价（万元/亩）
comm_sup = req_dict.get("comm_sup") # 商办土地供应量
represent = req_dict.get("represent") # 代表企业
# 投资成本
resident_ele_one = req_dict.get("resident_ele_one") # 居民用电（一档）（元/度）
resident_ele_two = req_dict.get("resident_ele_two") # 居民用电（二档）（元/度）
resident_ele_thr = req_dict.get("resident_ele_thr") # 居民用电（三档）（元/度）
comm_ele_one = req_dict.get("comm_ele_one") # 商业用电（峰段）（元/度）
comm_ele_two = req_dict.get("comm_ele_two") # 商业用电（平段）（元/度）
comm_ele_thr = req_dict.get("comm_ele_thr") # 商业用电（谷段）（元/度）
indu_ele_one = req_dict.get("indu_ele_one") # 工业用电（峰段）（元/度）
indu_ele_two = req_dict.get("indu_ele_two") # 工业用电（平段）（元/度）
indu_ele_thr = req_dict.get("indu_ele_thr") # 工业用电（谷段）（元/度）
resident_water_one = req_dict.get("resident_water_one") # 居民用水（一档）（元/吨）
resident_water_two = req_dict.get("resident_water_two") # 居民用水（二档）（元/吨）
resident_water_thr = req_dict.get("resident_water_thr") # 居民用水（三档）（元/吨）
comm_water = req_dict.get("comm_water") # 商业用水（元/吨）
indu_water = req_dict.get("indu_water") # 工业用水（元/吨）
special_water = req_dict.get("special_water") # 特种用水（元/吨）
resident_natgas_one = req_dict.get("resident_natgas_one") # 居民用气（一档）（元/m³）
resident_natgas_two = req_dict.get("resident_natgas_two") # 居民用气（二档）（元/m³）
resident_natgas_thr = req_dict.get("resident_natgas_thr") # 居民用气（三档）（元/m³）
sewage = req_dict.get("sewage") # 污水处理（元/吨）
wagelevel = req_dict.get("wagelevel") # 最低工资标准（元/月）
worker = req_dict.get("worker") # 普通员工（元/月）
middlemag = req_dict.get("middlemag") # 中级管理人员（元/月）
highmag = req_dict.get("highmag") # 高层管理人员（元/月）
# 环境配套
dis_freight = req_dict.get("dis_freight") # 距离货运站距离
dis_rail = req_dict.get("dis_rail") # 距离高铁站
dis_port = req_dict.get("dis_port") # 距离港口距离
dis_air = req_dict.get("dis_air") # 距离机场距离
road_trans = req_dict.get("road_trans") # 公路运输
rail_trans = req_dict.get("rail_trans") # 铁路运输
live_facility = req_dict.get("live_facility") # 园区生活配套
market = req_dict.get("market") # 百货商场
hotel_bus = req_dict.get("hotel_bus") # 酒店商务
medical = req_dict.get("medical") # 医疗机构
education = req_dict.get("education") # 学校教育
induenterprise = req_dict.get("induenterprise") # 规模以上企业
innovate = req_dict.get("innovate") # 科研机构
base = req_dict.get("base") # 双创基地
carrier = req_dict.get("carrier") # 产业载体
if not all([name, level, charge, phone, cate, address, cluster, area, acreage, actarea, tax, out_power,
invest_power, indu_land, indu_need, gdp, fiscal, indu_sup, comm_land, comm_sup, represent]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
cluster = ",".join(cluster)
try:
garden = Garden.query.get(id)
garden.name = name
garden.level = level
garden.charge = charge
garden.phone = phone
garden.cate = cate
garden.address = address
garden.cluster = cluster
garden.area = area
garden.acreage = acreage
garden.actarea = actarea
garden.tax = tax
garden.out_power = out_power
garden.invest_power = invest_power
garden.indu_need = indu_need
garden.gdp = gdp
garden.fiscal = fiscal
garden.indu_land = indu_land
garden.indu_sup = indu_sup
garden.comm_land = comm_land
garden.comm_sup = comm_sup
garden.represent = represent
if resident_ele_one:
garden.resident_ele_one = resident_ele_one
if resident_ele_two:
garden.resident_ele_two = resident_ele_two
if resident_ele_thr:
garden.resident_ele_thr = resident_ele_thr
if comm_ele_one:
garden.comm_ele_one = comm_ele_one
if comm_ele_two:
garden.comm_ele_two = comm_ele_two
if comm_ele_thr:
garden.comm_ele_thr = comm_ele_thr
if indu_ele_one:
garden.indu_ele_one = indu_ele_one
if indu_ele_two:
garden.indu_ele_two = indu_ele_two
if indu_ele_thr:
garden.indu_ele_thr = indu_ele_thr
if resident_water_one:
garden.resident_water_one = resident_water_one
if resident_water_two:
garden.resident_water_two = resident_water_two
if resident_water_thr:
garden.resident_water_thr = resident_water_thr
if comm_water:
garden.comm_water = comm_water
if indu_water:
garden.indu_water = indu_water
if special_water:
garden.special_water = special_water
if resident_natgas_one:
garden.resident_natgas_one = resident_natgas_one
if resident_natgas_two:
garden.resident_natgas_two = resident_natgas_two
if resident_natgas_thr:
garden.resident_natgas_thr = resident_natgas_thr
if sewage:
garden.sewage = sewage
if wagelevel:
garden.wagelevel = wagelevel
if worker:
garden.worker = worker
if middlemag:
garden.middlemag = middlemag
if highmag:
garden.highmag = highmag
if dis_freight:
garden.dis_freight = dis_freight
if dis_rail:
garden.dis_rail = dis_rail
if dis_port:
garden.dis_port = dis_port
if dis_air:
garden.dis_air = dis_air
if road_trans:
garden.road_trans = road_trans
if rail_trans:
garden.rail_trans = rail_trans
if live_facility:
garden.live_facility = live_facility
if market:
garden.market = market
if hotel_bus:
garden.hotel_bus = hotel_bus
if medical:
garden.medical = medical
if education:
garden.education = education
if induenterprise:
garden.induenterprise = induenterprise
if innovate:
garden.innovate = innovate
if base:
garden.base = base
if carrier:
garden.carrier = carrier
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 园区查看
@api_manage.route("/detailGarden", methods=["POST"])
# @login_required
def detail_garden():
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
if not all([id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
garden = Garden.query.get(id)
if garden:
data = {"id": garden.id,
"name": garden.name,
"level": garden.level,
"charge": garden.charge,
"phone": garden.phone,
"cate": garden.cate,
"address": garden.address,
"cluster": garden.cluster,
"area": garden.area,
"acreage": garden.acreage,
"actarea": garden.actarea,
"tax": garden.tax,
"out_power": garden.out_power,
"invest_power": garden.invest_power,
"indu_need": garden.indu_need,
"gdp": garden.gdp,
"fiscal": garden.fiscal,
"indu_land": garden.indu_land,
"indu_sup": garden.indu_sup,
"comm_land": garden.comm_land,
"comm_sup": garden.comm_sup,
"represent": garden.represent,
"resident_ele_one": garden.resident_ele_one if garden.resident_ele_one else "-",
"resident_ele_two": garden.resident_ele_two if garden.resident_ele_two else "-",
"resident_ele_thr": garden.resident_ele_thr if garden.resident_ele_thr else "-",
"comm_ele_one": garden.comm_ele_one if garden.comm_ele_one else "-",
"comm_ele_two": garden.comm_ele_two if garden.comm_ele_two else "-",
"comm_ele_thr": garden.resident_ele_thr if garden.comm_ele_thr else "-",
"indu_ele_one": garden.indu_ele_one if garden.indu_ele_one else "-",
"indu_ele_two": garden.indu_ele_two if garden.indu_ele_two else "-",
"indu_ele_thr": garden.indu_ele_thr if garden.indu_ele_thr else "-",
"resident_water_one": garden.resident_water_one if garden.resident_water_one else "-",
"resident_water_two": garden.resident_water_two if garden.resident_water_two else "-",
"resident_water_thr": garden.resident_water_thr if garden.resident_water_thr else "-",
"comm_water": garden.comm_water if garden.comm_water else "-",
"indu_water": garden.indu_water if garden.indu_water else "-",
"special_water": garden.special_water if garden.special_water else "-",
"resident_natgas_one": garden.resident_natgas_one if garden.resident_natgas_one else "-",
"resident_natgas_two": garden.resident_natgas_two if garden.resident_natgas_two else "-",
"resident_natgas_thr": garden.resident_natgas_thr if garden.resident_natgas_thr else "-",
"sewage": garden.sewage if garden.sewage else "-",
"wagelevel": garden.wagelevel if garden.wagelevel else "-",
"worker": garden.worker if garden.worker else "-",
"middlemag": garden.middlemag if garden.middlemag else "-",
"highmag": garden.highmag if garden.highmag else "-",
"dis_freight": garden.dis_freight if garden.dis_freight else "-",
"dis_rail": garden.dis_rail if garden.dis_rail else "-",
"dis_port": garden.dis_port if garden.dis_port else "-",
"dis_air": garden.dis_air if garden.dis_air else "-",
"road_trans": garden.road_trans if garden.road_trans else "-",
"rail_trans": garden.rail_trans if garden.rail_trans else "-",
"live_facility": garden.live_facility if garden.live_facility else "-",
"market": garden.market if garden.market else "-",
"hotel_bus": garden.hotel_bus if garden.hotel_bus else "-",
"medical": garden.medical if garden.medical else "-",
"education": garden.education if garden.education else "-",
"induenterprise": garden.induenterprise if garden.induenterprise else "-",
"innovate": garden.innovate if garden.innovate else "-",
"base": garden.base if garden.base else "-",
"carrier": garden.carrier if garden.carrier else "-",
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
return jsonify(code=RET.OK, msg="没有文件", data=False)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
@api_manage.route("/downModel", methods=["GET"])
# @login_required
def down_model():
'''带中文名本地文件下载'''
# filename = request.args.get('indu_name') + ".xlsx"
filename = "××园区调研问卷附表.xlsx"
# http://127.0.0.1:5000/api/manage/downModel
url = pro_url + "/model/" + filename
return jsonify(code=RET.OK, msg='下载成功', url=url, filename=filename)
# # 规模下载 二进制文件流
# @api_manage.route("/downFilewa", methods=["GET"])
# # @login_required
# def down_filewa():
# '''带中文名本地文件下载'''
# # filename = request.args.get('indu_name') + ".xlsx"
# filename = "全国省市区信息.xlsx"
# # http://127.0.0.1:5000/api/manage/downModel
# directory = os.getcwd() + "/apps/static/files/" # 文件目录
# response = make_response(send_from_directory(directory, filename, as_attachment=True))
# response.headers["Content-Disposition"] = "attachment; filename={}".format(filename.encode().decode('latin-1'))
# return response
''''''
# 检查是否有文件
@api_manage.route("/checkFile", methods=["POST"])
def check_file():
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
if not id:
return jsonify(code=RET.PARAMERR, msg="数据不完整")
try:
garden = Garden.query.get(id)
if garden.url_file:
return jsonify(code=RET.OK, msg="已有文件", data=True)
return jsonify(code=RET.OK, msg="没有文件", data=False)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 上传文件，限制大小16M，提示5M
@api_manage.route("/upFile", methods=["POST"])
def up_file():
# user_id = g.user_id
req_dict = request.form.to_dict()
id = req_dict.get('id') # 园区id
file = request.files.get('file')
if not file:
return jsonify(code=RET.NODATA, msg="文件未上传")
# 文件从request,files获取，这里使用CombinedMultiDict把form和file的数据组合起来，一起验证
form = UploadFormFile(CombinedMultiDict([request.form, request.files]))
if not form.validate():
return jsonify(code=RET.DATAERR, msg=form.errors)
# 保存到本地服务器
image_name = file.filename
url = image_name
# 保存文件名到数据库中
try:
garden = Garden.query.filter_by(id=id).first()
# 删除原文件
if garden.url_file:
filename = str(garden.url_file)
path = os.getcwd() + "/apps/static/files/" + filename
os.unlink(path)
# 保存新文件
file.save('./apps/static/files/{}'.format(image_name))
# 提交新文件名
garden.url_file = url
db.session.commit()
return jsonify(code=RET.OK, msg="保存成功")
file.save('./apps/static/files/{}'.format(image_name))
garden.url_file = url
db.session.commit()
return jsonify(code=RET.OK, msg="保存成功")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="保存文件失败")
# # 上传文件，限制大小16M，提示5M
# @api_manage.route("/upFile", methods=["POST"])
# def up_file():
# # user_id = g.user_id
# req_dict = request.form.to_dict()
# id = req_dict.get('id') # 园区id
# file = request.files.get('file')
# print(file.filename)
# if not file:
# return jsonify(code = RET.NODATA, msg = "文件未上传")
#
# # 文件从request,files获取，这里使用CombinedMultiDict把form和file的数据组合起来，一起验证
# form = UploadFormFile(CombinedMultiDict([request.form, request.files]))
# if not form.validate():
# return jsonify(code =RET.DATAERR, msg=form.errors)
#
# # 保存到本地服务器
# image_name = file.filename
# url = image_name
#
# # 保存文件名到数据库中
# try:
# garden = Garden.query.filter_by(id=id).first()
# # 删除原文件
# filename = str(garden.url_file)
# path = os.getcwd() + "/apps/static/files/" + filename
# os.unlink(path)
# # 保存新文件
# file.save('./apps/static/files/{}'.format(image_name))
# # 提交新文件名
# garden.url_file = url
# db.session.commit()
# except Exception as e:
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code =RET.DBERR, msg ="保存文件失败")
#
# return jsonify(code =RET.OK, msg ="保存成功")
# 文件下载
@api_manage.route("/downFile", methods=["POST"])
# @login_required
def down_file():
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
# id = 1 # 园区id
try:
garden = Garden.query.get(id)
if garden.url_file:
filename = str(garden.url_file)
url = pro_url + "/files/"+filename
return jsonify(code = RET.OK,msg = "上传成功",url = url,filename = filename)
# directory = os.getcwd() + "/apps/static/files/" # 文件目录
# response = make_response(send_from_directory(directory, filename, as_attachment=True))
# response.headers["Content-Disposition"] = "attachment; filename={}".format(
# filename.encode().decode('latin-1'))
# return response
return jsonify(code=RET.OK, msg="暂无文件")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# @api_manage.route("/downFile", methods=["POST"])
# # @login_required
# def down_file():
# req_dict = request.get_json()
# id = req_dict.get('id') # 园区id
# # id = 1 # 园区id
# try:
# garden = Garden.query.get(id)
# if garden.url_file:
# filename = str(garden.url_file)
# directory = os.getcwd() + "/apps/static/files/" # 文件目录
# response = make_response(send_from_directory(directory, filename, as_attachment=True))
# response.headers["Content-Disposition"] = "attachment; filename={}".format(
# filename.encode().decode('latin-1'))
# return response
# return jsonify(code=RET.OK, msg="暂无文件")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 资料上传
@api_manage.route("/upDoc", methods=["POST"])
@login_required
def up_doc():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.form.to_dict()
id = req_dict.get('id') # 园区id
size = req_dict.get("size") # 文件大小
file = request.files.get('file')
if not file:
return jsonify(code=RET.NODATA, msg="文件未上传")
# 文件从request,files获取，这里使用CombinedMultiDict把form和file的数据组合起来，一起验证
form = UploadFormFile(CombinedMultiDict([request.form, request.files]))
if not form.validate():
return jsonify(code=RET.DATAERR, msg=form.errors)
# 保存到本地服务器
image_name = "{}".format(int(time.time())) + file.filename
# 保存文件名到数据库中
try:
user = User.query.get(user_id)
garden = Garden.query.get(id)
gfile = Gfile(name=image_name, size=size, uperson=user.real_name, cate=1)
db.session.add(gfile)
file.save('./apps/static/projectfile/{}'.format(image_name))
garden.document.append(gfile)
db.session.commit()
file_id = gfile.id
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="保存文件失败")
data = {"filename": image_name, "uperson": user.real_name, "id": file_id}
return jsonify(code=RET.OK, msg="保存成功", data=data)
# 获取园区资料列表
@api_manage.route("/listDoc", methods=["POST"])
# @login_required
def list_doc():
# user_id = g.user_id
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
try:
garden = Garden.query.get(id)
docs = garden.document
data = [{"id": i.id,
"filename": i.name[10:],
"size": i.size,
"uperson": i.uperson
} for i in docs if i.cate == 1]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
# db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="服务器错误")
# # 获取园区资料列表
# @api_manage.route("/listDoc", methods=["POST"])
# # @login_required
# def list_doc():
# # user_id = g.user_id
# req_dict = request.form.to_dict()
# id = req_dict.get('id') # 园区id
# try:
# garden = Garden.query.get(id)
# docs = garden.document
# data = [{"id": i.id,
# "filename": i.name,
# "size": i.size,
# "uperson": i.uperson
# } for i in docs if i.cate == 1]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# # db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="保存文件失败")
# 文件下载
@api_manage.route("/downDoc", methods=["POST"])
# @login_required
def down_doc():
req_dict = request.get_json()
id = req_dict.get('id') # 文件id
try:
gfile = Gfile.query.get(id)
if gfile:
filename = str(gfile.name)
url = pro_url + "/projectfile/" + filename
return jsonify(code=RET.OK, msg="查找成功", filename=filename, url=url)
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# # 文件下载
# @api_manage.route("/downDoc", methods=["POST"])
# # @login_required
# def down_doc():
# req_dict = request.get_json()
# id = req_dict.get('id') # 文件id
# try:
# gfile = Gfile.query.get(id)
# if gfile:
# filename = str(gfile.name)
# directory = os.getcwd() + "/apps/static/projectfile/" # 文件目录
# response = make_response(send_from_directory(directory, filename, as_attachment=True))
# response.headers["Content-Disposition"] = "attachment; filename={}".format(
# filename.encode().decode('latin-1'))
# return response
# return jsonify(code=RET.DATAERR, msg="参数错误")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
''''''
# 文件删除
@api_manage.route("/deleteDoc", methods=["POST"])
# @login_required
def delete_doc():
req_dict = request.get_json()
id = req_dict.get('id') # 文件id
try:
gfile = Gfile.query.get(id)
if gfile:
db.session.delete(gfile)
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 图片上传
@api_manage.route("/upImage", methods=["POST"])
@login_required
def up_image():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.form.to_dict()
id = req_dict.get('id') # 园区id
file = request.files.get('file')
if not file:
return jsonify(code=RET.NODATA, msg="文件未上传")
# 保存到本地服务器
image_name = "{}".format((int(time.time()))) + file.filename
# 保存文件名到数据库中
try:
user = User.query.get(user_id)
garden = Garden.query.get(id)
gfile = Gfile(name=image_name, uperson=user.real_name, cate=2)
db.session.add(gfile)
file.save('./apps/static/image/{}'.format(image_name))
garden.document.append(gfile)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="保存文件失败")
image_id = gfile.id
data = {"filename": image_name, "uperson": user.real_name, "id": image_id}
return jsonify(code=RET.OK, msg="保存成功", data=data)
# 获取园区图片列表
@api_manage.route("/listImage", methods=["POST"])
# @login_required
def list_img():
# user_id = g.user_id
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
try:
garden = Garden.query.get(id)
docs = garden.document
data = [{"id": i.id,
"url": pro_url + "/image/" + i.name,
} for i in docs if i.cate == 2]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
# db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
apps/inves_manage/view_zone.py 0 → 100644
import os
import json
from flask import g, current_app, request, jsonify, session, send_from_directory, make_response
from apps.inves_manage import api_manage, pro_url
# from apps.utils.commons import login_required
from apps.util import verify_token
from apps.util import login_required
from apps.utils.response_code import RET
from apps.models import *
from apps.utils.read_json import open_type
from datetime import datetime, timedelta
from sqlalchemy import extract, or_, and_
from sqlalchemy.sql import func
import datetime
import filetype
import time
from apps.utils.forms import *
from werkzeug.datastructures import CombinedMultiDict
# 获取筛选条件
@api_manage.route("/getFiled", methods=["GET"])
@login_required
def get_filed():
try:
zone = Zone.query.filter_by(statu=1)
cates = zone.filter_by(sid=1).all() # 类别
levels = zone.filter_by(sid=2).all() # 级别
# options: [{value: "选项1", label: "无数据"}, {value: "选项2", label: "3333"}],
data = {"cate": [{"label": i.name, "value": i.nid} for i in cates], # [i.name for i in cates],
"level": [{"label": i.name, "value": i.nid} for i in levels], # [i.name for i in levels],
"indu": [{"label": "高端装备", "value": 1}, {"label": "新材料", "value": 2},
{"label": "新一代信息技术", "value": 3}, {"label": "现代服务业", "value": 4}],
"status": [{"label": "未上报", "value": 1}, {"label": "审核通过", "value": 2},
{"label": "审核驳回", "value": 3}, {"label": "正在审核", "value": 4}]
}
data["cate"].insert(0, {"label": "请选择", "value": ""})
data["level"].insert(0, {"label": "请选择", "value": ""})
data["indu"].insert(0, {"label": "请选择", "value": ""})
data["status"].insert(0, {"label": "请选择", "value": ""})
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 获取园区列表（层级权限）
@api_manage.route("/listOfGarden", methods=["POST"])
@login_required
def list_garden():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.get_json()
key = req_dict.get("key")
indu = req_dict.get("indu")
level = req_dict.get("level")
cate = req_dict.get("cate")
status = req_dict.get("status")
page = req_dict.get("page")
perpage = req_dict.get("perpage")
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.get(user_id) # 获取当前用户
role = user.role # 获取角色
unit = user.unit # 用户机构
section = user.section # 用户部门
garden = Garden.query.filter_by()
# garden = garden.filter(Garden.cluster.like("%{}%".format(indu)))
if indu:
garden = garden.filter(Garden.cluster.like("%{}%".format(indu)))
if level:
garden = garden.filter_by(level=level)
if cate:
garden = garden.filter_by(cate=cate)
if status:
garden = garden.filter_by(status=status)
if key:
garden = garden.filter(Garden.name.like("%{}%".format(key)))
if role.role[0] == "1": # 机构领导（看全部）
maxnum = garden.filter(or_(Garden.unit == unit, Garden.up_unit == unit)).count()
gardens = garden.filter(or_(Garden.unit == unit, Garden.up_unit == unit)).paginate(page, perpage).items
data = [{"id": i.id,
"name": i.name,
"address": i.address,
"level": i.level,
"cate": i.cate,
"charge": i.charge,
"phone": i.phone,
"uperson": i.uperson if i.uperson else "",
"unit": i.up_unit,
"status": i.status if i.status else ""} for i in gardens]
data = {"data_lis": data, "maxnum": maxnum}
return jsonify(code=RET.OK, msg="查询成功", data=data)
if role.role[0] == "2": # 部门领导（看部门），自己部门，上报给自己机构的
# print("===========")
gardens = garden.filter(
or_(Garden.up_unit == unit, and_(Garden.unit == unit, Garden.section == section))).paginate(page,
perpage).items
maxnum = garden.filter(
or_(Garden.up_unit == unit, and_(Garden.unit == unit, Garden.section == section))).count()
# print(gardens)
data = [{"id": i.id,
"name": i.name,
"address": i.address,
"level": i.level,
"cate": i.cate,
"charge": i.charge,
"phone": i.phone,
"uperson": i.uperson if i.uperson else "",
"unit": i.up_unit,
"status": i.status if i.status else ""} for i in gardens]
data = {"data_lis": data, "maxnum": maxnum}
return jsonify(code=RET.OK, msg="查询成功", data=data)
if role.role[0] == "3": # 自己看自己,+上报给自己机构的
gardens = garden.filter(or_(Garden.user == user_id, Garden.up_unit == unit))
maxnum = gardens.count()
# print(gardens)
gardens = gardens.paginate(page, perpage).items
# print(gardens)
data = [{"id": i.id,
"name": i.name,
"address": i.address,
"level": i.level,
"cate": i.cate,
"charge": i.charge,
"phone": i.phone,
"uperson": i.uperson if i.uperson else "",
"unit": i.up_unit,
"status": i.status if i.status else ""} for i in gardens]
data = {"data_lis": data, "maxnum": maxnum}
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 园区新增
@api_manage.route("/addGarden", methods=["POST"])
@login_required
def add_garden():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
role = user.role.role
if not role:
return jsonify(code=RET.OK, msg="无权限查看此内容")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
role = user.role
if role.role[5] != "1":
return jsonify(code=RET.REQERR, msg="暂无权限")
req_dict = request.get_json()
# 基本信息*
name = req_dict.get("name") # 园区姓名
level = req_dict.get("level") # 园区级别
charge = req_dict.get("charge") # 园区负责人
phone = req_dict.get("phone") # 园区联系电话
cate = req_dict.get("cate") # 园区类型
address = req_dict.get("address") # 园区地址
cluster = req_dict.get("cluster") # 产业集群（多选）[]
area = req_dict.get("area") # 占地面积(平方公里)
acreage = req_dict.get("acreage") # 规划面积（平方公里）
gdp = req_dict.get("gdp") # GDP(亿元)
# 土地信息
land_code = req_dict.get("land_code") # 土地位置/编号
land_property = req_dict.get("land_property") # 土地性质
land_range = req_dict.get("land_range") # 土地范围
land_size = req_dict.get("land_size") # 土地面积/平方公里
indu_appeal = req_dict.get("indu_appeal") # 产业诉求
# 楼宇信息
build_name = req_dict.get("build_name") # 楼宇名称
build_add = req_dict.get("build_add") # 楼宇地址
build_size = req_dict.get("build_size") # 楼宇面积/平方公里
build_appeal = req_dict.get("build_appeal") # 楼宇诉求
# 厂房信息
plant_add = req_dict.get("plant_add") # 厂房位置
plant_size = req_dict.get("plant_size") # 厂房面积
plant_condition = req_dict.get("plant_condition") # 厂房条件
# 投资成本
resident_ele_one = req_dict.get("resident_ele_one") # 居民用电（一档）（元/度）
resident_ele_two = req_dict.get("resident_ele_two") # 居民用电（二档）（元/度）
resident_ele_thr = req_dict.get("resident_ele_thr") # 居民用电（三档）（元/度）
comm_ele_one = req_dict.get("comm_ele_one") # 商业用电（峰段）（元/度）
comm_ele_two = req_dict.get("comm_ele_two") # 商业用电（平段）（元/度）
comm_ele_thr = req_dict.get("comm_ele_thr") # 商业用电（谷段）（元/度）
indu_ele_one = req_dict.get("indu_ele_one") # 工业用电（峰段）（元/度）
indu_ele_two = req_dict.get("indu_ele_two") # 工业用电（平段）（元/度）
indu_ele_thr = req_dict.get("indu_ele_thr") # 工业用电（谷段）（元/度）
resident_water_one = req_dict.get("resident_water_one") # 居民用水（一档）（元/吨）
resident_water_two = req_dict.get("resident_water_two") # 居民用水（二档）（元/吨）
resident_water_thr = req_dict.get("resident_water_thr") # 居民用水（三档）（元/吨）
comm_water = req_dict.get("comm_water") # 商业用水（元/吨）
indu_water = req_dict.get("indu_water") # 工业用水（元/吨）
special_water = req_dict.get("special_water") # 特种用水（元/吨）
resident_natgas_one = req_dict.get("resident_natgas_one") # 居民用气（一档）（元/m³）
resident_natgas_two = req_dict.get("resident_natgas_two") # 居民用气（二档）（元/m³）
resident_natgas_thr = req_dict.get("resident_natgas_thr") # 居民用气（三档）（元/m³）
sewage = req_dict.get("sewage") # 污水处理（元/吨）
wagelevel = req_dict.get("wagelevel") # 最低工资标准（元/月）
worker = req_dict.get("worker") # 普通员工（元/月）
middlemag = req_dict.get("middlemag") # 中级管理人员（元/月）
highmag = req_dict.get("highmag") # 高层管理人员（元/月）
# 环境配套
dis_freight = req_dict.get("dis_freight") # 距离货运站距离
dis_rail = req_dict.get("dis_rail") # 距离高铁站
dis_port = req_dict.get("dis_port") # 距离港口距离
dis_air = req_dict.get("dis_air") # 距离机场距离
road_trans = req_dict.get("road_trans") # 公路运输
rail_trans = req_dict.get("rail_trans") # 铁路运输
live_facility = req_dict.get("live_facility") # 园区生活配套
market = req_dict.get("market") # 百货商场
hotel_bus = req_dict.get("hotel_bus") # 酒店商务
medical = req_dict.get("medical") # 医疗机构
education = req_dict.get("education") # 学校教育
induenterprise = req_dict.get("induenterprise") # 规模以上企业
innovate = req_dict.get("innovate") # 科研机构
base = req_dict.get("base") # 双创基地
carrier = req_dict.get("carrier") # 产业载体
if not all([name, level, charge, phone, cate, address, cluster, area, acreage]):
return jsonify(code=RET.PARAMERR, msg="基本信息请填完整")
cluster = ",".join(cluster)
try:
user = User.query.get(user_id)
unit = user.unit
section = user.section
garden = Garden(unit=unit, section=section, user=user_id, name=name, level=level, charge=charge, phone=phone,
cate=cate, address=address, cluster=cluster, area=area, acreage=acreage, gdp=gdp,
land_code=land_code, land_property=land_property, land_range=land_range, land_size=land_size,
indu_appeal=indu_appeal, build_name=build_name, build_add=build_add, build_size=build_size,
build_appeal=build_appeal, plant_add=plant_add, plant_size=plant_size,
plant_condition=plant_condition)
if resident_ele_one:
garden.resident_ele_one = resident_ele_one
if resident_ele_two:
garden.resident_ele_two = resident_ele_two
if resident_ele_thr:
garden.resident_ele_thr = resident_ele_thr
if comm_ele_one:
garden.comm_ele_one = comm_ele_one
if comm_ele_two:
garden.comm_ele_two = comm_ele_two
if comm_ele_thr:
garden.comm_ele_thr = comm_ele_thr
if indu_ele_one:
garden.indu_ele_one = indu_ele_one
if indu_ele_two:
garden.indu_ele_two = indu_ele_two
if indu_ele_thr:
garden.indu_ele_thr = indu_ele_thr
if resident_water_one:
garden.resident_water_one = resident_water_one
if resident_water_two:
garden.resident_water_two = resident_water_two
if resident_water_thr:
garden.resident_water_thr = resident_water_thr
if comm_water:
garden.comm_water = comm_water
if indu_water:
garden.indu_water = indu_water
if special_water:
garden.special_water = special_water
if resident_natgas_one:
garden.resident_natgas_one = resident_natgas_one
if resident_natgas_two:
garden.resident_natgas_two = resident_natgas_two
if resident_natgas_thr:
garden.resident_natgas_thr = resident_natgas_thr
if sewage:
garden.sewage = sewage
if wagelevel:
garden.wagelevel = wagelevel
if worker:
garden.worker = worker
if middlemag:
garden.middlemag = middlemag
if highmag:
garden.highmag = highmag
if dis_freight:
garden.dis_freight = dis_freight
if dis_rail:
garden.dis_rail = dis_rail
if dis_port:
garden.dis_port = dis_port
if dis_air:
garden.dis_air = dis_air
if road_trans:
garden.road_trans = road_trans
if rail_trans:
garden.rail_trans = rail_trans
if live_facility:
garden.live_facility = live_facility
if market:
garden.market = market
if hotel_bus:
garden.hotel_bus = hotel_bus
if medical:
garden.medical = medical
if education:
garden.education = education
if induenterprise:
garden.induenterprise = induenterprise
if innovate:
garden.innovate = innovate
if base:
garden.base = base
if carrier:
garden.carrier = carrier
db.session.add(garden)
db.session.commit()
garden_id = garden.id
return jsonify(code=RET.OK, msg="添加成功", id=garden_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 园区审核
@api_manage.route("/passGarden", methods=["POST"])
@login_required
def pass_garden():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
role = user.role
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
if role.role[4] != "1":
return jsonify(code=RET.REQERR, msg="暂无权限")
req_dict = request.get_json()
id = req_dict.get("id") # 园区id
advice = req_dict.get("advice") # 1通过，2驳回
if not all([id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
garden = Garden.query.get(id)
if advice == 1:
garden.status = "审核通过"
db.session.commit()
return jsonify(code=RET.OK, msg="已通过")
else:
garden.status = "审核驳回"
db.session.commit()
return jsonify(code=RET.OK, msg="已驳回")
except Exception as e:
db.session.rollabck()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 园区上报
@api_manage.route("/sendGarden", methods=["POST"])
@login_required
def send_garden():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
role = user.role
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
if role.role[4] != "1":
return jsonify(code=RET.REQERR, msg="暂无权限")
req_dict = request.get_json()
id = req_dict.get("id") # 园区id
org = req_dict.get("org") # 待上报机构名
if not all([id, org]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
garden = Garden.query.get(id)
garden.uperson = user.name
garden.up_unit = org
garden.status = "正在审核"
db.session.commit()
return jsonify(code=RET.OK, msg="上报成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 园区修改
@api_manage.route("/editGarden", methods=["POST"])
@login_required
def edit_garden():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
user = User.query.get(user_id)
role = user.role
if role.role[5] != "1":
return jsonify(code=RET.REQERR, msg="暂无权限")
req_dict = request.get_json()
id = req_dict.get("id") # 园区id
name = req_dict.get("name") # 园区姓名
level = req_dict.get("level") # 园区级别
charge = req_dict.get("charge") # 园区负责人
phone = req_dict.get("phone") # 园区联系电话
cate = req_dict.get("cate") # 园区类型
address = req_dict.get("address") # 园区地址
cluster = req_dict.get("cluster") # 产业集群（多选）
# 园区信息
area = req_dict.get("area") # 占地面积(平方公里)
acreage = req_dict.get("acreage") # 规划面积（平方公里）
gdp = req_dict.get("gdp") # GDP(亿元)
# 土地信息
land_code = req_dict.get("land_code") # 土地位置/编号
land_property = req_dict.get("land_property") # 土地性质
land_range = req_dict.get("land_range") # 土地范围
land_size = req_dict.get("land_size") # 土地面积/平方公里
indu_appeal = req_dict.get("indu_appeal") # 产业诉求
# 楼宇信息
build_name = req_dict.get("build_name") # 楼宇名称
build_add = req_dict.get("build_add") # 楼宇地址
build_size = req_dict.get("build_size") # 楼宇面积/平方公里
build_appeal = req_dict.get("build_appeal") # 楼宇诉求
# 厂房信息
plant_add = req_dict.get("plant_add") # 厂房位置
plant_size = req_dict.get("plant_size") # 厂房面积
plant_condition = req_dict.get("plant_condition") # 厂房条件
# 投资成本
resident_ele_one = req_dict.get("resident_ele_one") # 居民用电（一档）（元/度）
resident_ele_two = req_dict.get("resident_ele_two") # 居民用电（二档）（元/度）
resident_ele_thr = req_dict.get("resident_ele_thr") # 居民用电（三档）（元/度）
comm_ele_one = req_dict.get("comm_ele_one") # 商业用电（峰段）（元/度）
comm_ele_two = req_dict.get("comm_ele_two") # 商业用电（平段）（元/度）
comm_ele_thr = req_dict.get("comm_ele_thr") # 商业用电（谷段）（元/度）
indu_ele_one = req_dict.get("indu_ele_one") # 工业用电（峰段）（元/度）
indu_ele_two = req_dict.get("indu_ele_two") # 工业用电（平段）（元/度）
indu_ele_thr = req_dict.get("indu_ele_thr") # 工业用电（谷段）（元/度）
resident_water_one = req_dict.get("resident_water_one") # 居民用水（一档）（元/吨）
resident_water_two = req_dict.get("resident_water_two") # 居民用水（二档）（元/吨）
resident_water_thr = req_dict.get("resident_water_thr") # 居民用水（三档）（元/吨）
comm_water = req_dict.get("comm_water") # 商业用水（元/吨）
indu_water = req_dict.get("indu_water") # 工业用水（元/吨）
special_water = req_dict.get("special_water") # 特种用水（元/吨）
resident_natgas_one = req_dict.get("resident_natgas_one") # 居民用气（一档）（元/m³）
resident_natgas_two = req_dict.get("resident_natgas_two") # 居民用气（二档）（元/m³）
resident_natgas_thr = req_dict.get("resident_natgas_thr") # 居民用气（三档）（元/m³）
sewage = req_dict.get("sewage") # 污水处理（元/吨）
wagelevel = req_dict.get("wagelevel") # 最低工资标准（元/月）
worker = req_dict.get("worker") # 普通员工（元/月）
middlemag = req_dict.get("middlemag") # 中级管理人员（元/月）
highmag = req_dict.get("highmag") # 高层管理人员（元/月）
# 环境配套
dis_freight = req_dict.get("dis_freight") # 距离货运站距离
dis_rail = req_dict.get("dis_rail") # 距离高铁站
dis_port = req_dict.get("dis_port") # 距离港口距离
dis_air = req_dict.get("dis_air") # 距离机场距离
road_trans = req_dict.get("road_trans") # 公路运输
rail_trans = req_dict.get("rail_trans") # 铁路运输
live_facility = req_dict.get("live_facility") # 园区生活配套
market = req_dict.get("market") # 百货商场
hotel_bus = req_dict.get("hotel_bus") # 酒店商务
medical = req_dict.get("medical") # 医疗机构
education = req_dict.get("education") # 学校教育
induenterprise = req_dict.get("induenterprise") # 规模以上企业
innovate = req_dict.get("innovate") # 科研机构
base = req_dict.get("base") # 双创基地
carrier = req_dict.get("carrier") # 产业载体
if not all([name, level, charge, phone, cate, address, cluster, area, acreage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
cluster = ",".join(cluster)
try:
garden = Garden.query.get(id)
garden.name = name
garden.level = level
garden.charge = charge
garden.phone = phone
garden.cate = cate
garden.address = address
garden.cluster = cluster
garden.area = area
garden.acreage = acreage
garden.gdp = gdp
garden.land_code = land_code
garden.land_property = land_property
garden.land_range = land_range
garden.land_size = land_size
garden.indu_appeal = indu_appeal
garden.build_name = build_name
garden.build_add = build_add
garden.build_size = build_size
garden.build_appeal = build_appeal
garden.plant_add = plant_add
garden.plant_size = plant_size
garden.plant_condition = plant_condition
if resident_ele_one:
garden.resident_ele_one = resident_ele_one
if resident_ele_two:
garden.resident_ele_two = resident_ele_two
if resident_ele_thr:
garden.resident_ele_thr = resident_ele_thr
if comm_ele_one:
garden.comm_ele_one = comm_ele_one
if comm_ele_two:
garden.comm_ele_two = comm_ele_two
if comm_ele_thr:
garden.comm_ele_thr = comm_ele_thr
if indu_ele_one:
garden.indu_ele_one = indu_ele_one
if indu_ele_two:
garden.indu_ele_two = indu_ele_two
if indu_ele_thr:
garden.indu_ele_thr = indu_ele_thr
if resident_water_one:
garden.resident_water_one = resident_water_one
if resident_water_two:
garden.resident_water_two = resident_water_two
if resident_water_thr:
garden.resident_water_thr = resident_water_thr
if comm_water:
garden.comm_water = comm_water
if indu_water:
garden.indu_water = indu_water
if special_water:
garden.special_water = special_water
if resident_natgas_one:
garden.resident_natgas_one = resident_natgas_one
if resident_natgas_two:
garden.resident_natgas_two = resident_natgas_two
if resident_natgas_thr:
garden.resident_natgas_thr = resident_natgas_thr
if sewage:
garden.sewage = sewage
if wagelevel:
garden.wagelevel = wagelevel
if worker:
garden.worker = worker
if middlemag:
garden.middlemag = middlemag
if highmag:
garden.highmag = highmag
if dis_freight:
garden.dis_freight = dis_freight
if dis_rail:
garden.dis_rail = dis_rail
if dis_port:
garden.dis_port = dis_port
if dis_air:
garden.dis_air = dis_air
if road_trans:
garden.road_trans = road_trans
if rail_trans:
garden.rail_trans = rail_trans
if live_facility:
garden.live_facility = live_facility
if market:
garden.market = market
if hotel_bus:
garden.hotel_bus = hotel_bus
if medical:
garden.medical = medical
if education:
garden.education = education
if induenterprise:
garden.induenterprise = induenterprise
if innovate:
garden.innovate = innovate
if base:
garden.base = base
if carrier:
garden.carrier = carrier
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 园区查看
@api_manage.route("/detailGarden", methods=["POST"])
# @login_required
def detail_garden():
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
if not all([id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
garden = Garden.query.get(id)
if garden:
data = {"id": garden.id,
"name": garden.name,
"level": garden.level,
"charge": garden.charge,
"phone": garden.phone,
"cate": garden.cate,
"address": garden.address,
"cluster": garden.cluster,
"area": garden.area,
"acreage": garden.acreage,
"gdp": garden.gdp,
"land_code": garden.land_code if garden.land_code else "-",
"land_property": garden.land_property if garden.land_property else "-",
"land_range": garden.land_range if garden.land_range else "-",
"land_size": garden.land_size if garden.land_size else "-",
"indu_appeal": garden.indu_appeal if garden.indu_appeal else "-",
"build_name": garden.build_name if garden.build_name else "-",
"build_add": garden.build_add if garden.build_add else "-",
"build_size": garden.build_size if garden.build_size else "-",
"build_appeal": garden.build_appeal if garden.build_appeal else "-",
"plant_add": garden.plant_add if garden.plant_add else "-",
"plant_size": garden.plant_size if garden.plant_size else "-",
"plant_condition": garden.plant_condition if garden.plant_condition else "-",
"resident_ele_one": garden.resident_ele_one if garden.resident_ele_one else "-",
"resident_ele_two": garden.resident_ele_two if garden.resident_ele_two else "-",
"resident_ele_thr": garden.resident_ele_thr if garden.resident_ele_thr else "-",
"comm_ele_one": garden.comm_ele_one if garden.comm_ele_one else "-",
"comm_ele_two": garden.comm_ele_two if garden.comm_ele_two else "-",
"comm_ele_thr": garden.resident_ele_thr if garden.comm_ele_thr else "-",
"indu_ele_one": garden.indu_ele_one if garden.indu_ele_one else "-",
"indu_ele_two": garden.indu_ele_two if garden.indu_ele_two else "-",
"indu_ele_thr": garden.indu_ele_thr if garden.indu_ele_thr else "-",
"resident_water_one": garden.resident_water_one if garden.resident_water_one else "-",
"resident_water_two": garden.resident_water_two if garden.resident_water_two else "-",
"resident_water_thr": garden.resident_water_thr if garden.resident_water_thr else "-",
"comm_water": garden.comm_water if garden.comm_water else "-",
"indu_water": garden.indu_water if garden.indu_water else "-",
"special_water": garden.special_water if garden.special_water else "-",
"resident_natgas_one": garden.resident_natgas_one if garden.resident_natgas_one else "-",
"resident_natgas_two": garden.resident_natgas_two if garden.resident_natgas_two else "-",
"resident_natgas_thr": garden.resident_natgas_thr if garden.resident_natgas_thr else "-",
"sewage": garden.sewage if garden.sewage else "-",
"wagelevel": garden.wagelevel if garden.wagelevel else "-",
"worker": garden.worker if garden.worker else "-",
"middlemag": garden.middlemag if garden.middlemag else "-",
"highmag": garden.highmag if garden.highmag else "-",
"dis_freight": garden.dis_freight if garden.dis_freight else "-",
"dis_rail": garden.dis_rail if garden.dis_rail else "-",
"dis_port": garden.dis_port if garden.dis_port else "-",
"dis_air": garden.dis_air if garden.dis_air else "-",
"road_trans": garden.road_trans if garden.road_trans else "-",
"rail_trans": garden.rail_trans if garden.rail_trans else "-",
"live_facility": garden.live_facility if garden.live_facility else "-",
"market": garden.market if garden.market else "-",
"hotel_bus": garden.hotel_bus if garden.hotel_bus else "-",
"medical": garden.medical if garden.medical else "-",
"education": garden.education if garden.education else "-",
"induenterprise": garden.induenterprise if garden.induenterprise else "-",
"innovate": garden.innovate if garden.innovate else "-",
"base": garden.base if garden.base else "-",
"carrier": garden.carrier if garden.carrier else "-",
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
return jsonify(code=RET.OK, msg="没有文件", data=False)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# TODO 文件操作等由于路径十分混乱，删除
@api_manage.route("/downModel", methods=["GET"])
# @login_required
def down_model():
'''带中文名本地文件下载'''
# filename = request.args.get('indu_name') + ".xlsx"
filename = "××园区调研问卷附表.xlsx"
# http://127.0.0.1:5000/api/manage/downModel
url = pro_url + "/model/" + filename
return jsonify(code=RET.OK, msg='下载成功', url=url, filename=filename)
# # 规模下载 二进制文件流
# @api_manage.route("/downFilewa", methods=["GET"])
# # @login_required
# def down_filewa():
# '''带中文名本地文件下载'''
# # filename = request.args.get('indu_name') + ".xlsx"
# filename = "全国省市区信息.xlsx"
# # http://127.0.0.1:5000/api/manage/downModel
# directory = os.getcwd() + "/apps/static/files/" # 文件目录
# response = make_response(send_from_directory(directory, filename, as_attachment=True))
# response.headers["Content-Disposition"] = "attachment; filename={}".format(filename.encode().decode('latin-1'))
# return response
''''''
# 检查是否有文件
@api_manage.route("/checkFile", methods=["POST"])
def check_file():
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
if not id:
return jsonify(code=RET.PARAMERR, msg="数据不完整")
try:
garden = Garden.query.get(id)
if garden.url_file:
return jsonify(code=RET.OK, msg="已有文件", data=True)
return jsonify(code=RET.OK, msg="没有文件", data=False)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 上传文件，限制大小16M，提示5M
@api_manage.route("/upFile", methods=["POST"])
def up_file():
# user_id = g.user_id
req_dict = request.form.to_dict()
id = req_dict.get('id') # 园区id
file = request.files.get('file')
if not file:
return jsonify(code=RET.NODATA, msg="文件未上传")
# 文件从request,files获取，这里使用CombinedMultiDict把form和file的数据组合起来，一起验证
form = UploadFormFile(CombinedMultiDict([request.form, request.files]))
if not form.validate():
return jsonify(code=RET.DATAERR, msg=form.errors)
# 保存到本地服务器
image_name = file.filename
url = image_name
# 保存文件名到数据库中
try:
garden = Garden.query.filter_by(id=id).first()
# 删除原文件
if garden.url_file:
filename = str(garden.url_file)
path = os.getcwd() + "/apps/static/files/" + filename
os.unlink(path)
# 保存新文件
file.save('./apps/static/files/{}'.format(image_name))
# 提交新文件名
garden.url_file = url
db.session.commit()
return jsonify(code=RET.OK, msg="保存成功")
file.save('./apps/static/files/{}'.format(image_name))
garden.url_file = url
db.session.commit()
return jsonify(code=RET.OK, msg="保存成功")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="保存文件失败")
# # 上传文件，限制大小16M，提示5M
# @api_manage.route("/upFile", methods=["POST"])
# def up_file():
# # user_id = g.user_id
# req_dict = request.form.to_dict()
# id = req_dict.get('id') # 园区id
# file = request.files.get('file')
# print(file.filename)
# if not file:
# return jsonify(code = RET.NODATA, msg = "文件未上传")
#
# # 文件从request,files获取，这里使用CombinedMultiDict把form和file的数据组合起来，一起验证
# form = UploadFormFile(CombinedMultiDict([request.form, request.files]))
# if not form.validate():
# return jsonify(code =RET.DATAERR, msg=form.errors)
#
# # 保存到本地服务器
# image_name = file.filename
# url = image_name
#
# # 保存文件名到数据库中
# try:
# garden = Garden.query.filter_by(id=id).first()
# # 删除原文件
# filename = str(garden.url_file)
# path = os.getcwd() + "/apps/static/files/" + filename
# os.unlink(path)
# # 保存新文件
# file.save('./apps/static/files/{}'.format(image_name))
# # 提交新文件名
# garden.url_file = url
# db.session.commit()
# except Exception as e:
# db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code =RET.DBERR, msg ="保存文件失败")
#
# return jsonify(code =RET.OK, msg ="保存成功")
# 文件下载
@api_manage.route("/downFile", methods=["POST"])
# @login_required
def down_file():
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
# id = 1 # 园区id
try:
garden = Garden.query.get(id)
if garden.url_file:
filename = str(garden.url_file)
url = pro_url + "/files/" + filename
return jsonify(code=RET.OK, msg="上传成功", url=url, filename=filename)
# directory = os.getcwd() + "/apps/static/files/" # 文件目录
# response = make_response(send_from_directory(directory, filename, as_attachment=True))
# response.headers["Content-Disposition"] = "attachment; filename={}".format(
# filename.encode().decode('latin-1'))
# return response
return jsonify(code=RET.OK, msg="暂无文件")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# @api_manage.route("/downFile", methods=["POST"])
# # @login_required
# def down_file():
# req_dict = request.get_json()
# id = req_dict.get('id') # 园区id
# # id = 1 # 园区id
# try:
# garden = Garden.query.get(id)
# if garden.url_file:
# filename = str(garden.url_file)
# directory = os.getcwd() + "/apps/static/files/" # 文件目录
# response = make_response(send_from_directory(directory, filename, as_attachment=True))
# response.headers["Content-Disposition"] = "attachment; filename={}".format(
# filename.encode().decode('latin-1'))
# return response
# return jsonify(code=RET.OK, msg="暂无文件")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 资料上传
@api_manage.route("/upDoc", methods=["POST"])
@login_required
def up_doc():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.form.to_dict()
id = req_dict.get('id') # 园区id
size = req_dict.get("size") # 文件大小
file = request.files.get('file')
if not file:
return jsonify(code=RET.NODATA, msg="文件未上传")
# # 文件从request,files获取，这里使用CombinedMultiDict把form和file的数据组合起来，一起验证
# form = UploadFormFile(CombinedMultiDict([request.form, request.files]))
# if not form.validate():
# return jsonify(code=RET.DATAERR, msg=form.errors)
# 保存到本地服务器
image_name = "{}".format(int(time.time())) + file.filename
# 保存文件名到数据库中
try:
user = User.query.get(user_id)
garden = Garden.query.get(id)
gfile = Gfile(name=image_name, size=size, uperson=user.real_name, cate=1)
db.session.add(gfile)
file.save('./apps/static/projectfile/{}'.format(image_name))
garden.document.append(gfile)
db.session.commit()
file_id = gfile.id
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="保存文件失败")
data = {"filename": image_name, "uperson": user.real_name, "id": file_id}
return jsonify(code=RET.OK, msg="保存成功", data=data)
# 获取园区资料列表
@api_manage.route("/listDoc", methods=["POST"])
# @login_required
def list_doc():
# user_id = g.user_id
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
try:
garden = Garden.query.get(id)
docs = garden.document
data = [{"id": i.id,
"filename": i.name[10:],
"size": i.size,
"uperson": i.uperson
} for i in docs if i.cate == 1]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
# db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="服务器错误")
# # 获取园区资料列表
# @api_manage.route("/listDoc", methods=["POST"])
# # @login_required
# def list_doc():
# # user_id = g.user_id
# req_dict = request.form.to_dict()
# id = req_dict.get('id') # 园区id
# try:
# garden = Garden.query.get(id)
# docs = garden.document
# data = [{"id": i.id,
# "filename": i.name,
# "size": i.size,
# "uperson": i.uperson
# } for i in docs if i.cate == 1]
# return jsonify(code=RET.OK, msg="查询成功", data=data)
# except Exception as e:
# # db.session.rollback()
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="保存文件失败")
# 文件下载
@api_manage.route("/downDoc", methods=["POST"])
# @login_required
def down_doc():
req_dict = request.get_json()
id = req_dict.get('id') # 文件id
try:
gfile = Gfile.query.get(id)
if gfile:
filename = str(gfile.name)
url = pro_url + "/projectfile/" + filename
return jsonify(code=RET.OK, msg="查找成功", filename=filename, url=url)
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# # 文件下载
# @api_manage.route("/downDoc", methods=["POST"])
# # @login_required
# def down_doc():
# req_dict = request.get_json()
# id = req_dict.get('id') # 文件id
# try:
# gfile = Gfile.query.get(id)
# if gfile:
# filename = str(gfile.name)
# directory = os.getcwd() + "/apps/static/projectfile/" # 文件目录
# response = make_response(send_from_directory(directory, filename, as_attachment=True))
# response.headers["Content-Disposition"] = "attachment; filename={}".format(
# filename.encode().decode('latin-1'))
# return response
# return jsonify(code=RET.DATAERR, msg="参数错误")
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="数据库查询错误")
''''''
# 文件删除
@api_manage.route("/deleteDoc", methods=["POST"])
# @login_required
def delete_doc():
req_dict = request.get_json()
id = req_dict.get('id') # 文件id
try:
gfile = Gfile.query.get(id)
if gfile:
db.session.delete(gfile)
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 图片上传
@api_manage.route("/upImage", methods=["POST"])
@login_required
def up_image():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.form.to_dict()
id = req_dict.get('id') # 园区id
file = request.files.get('file')
if not file:
return jsonify(code=RET.NODATA, msg="文件未上传")
# 保存到本地服务器
image_name = "{}".format((int(time.time()))) + file.filename
# 保存文件名到数据库中
try:
user = User.query.get(user_id)
garden = Garden.query.get(id)
gfile = Gfile(name=image_name, uperson=user.real_name, cate=2)
db.session.add(gfile)
file.save('./apps/static/image/{}'.format(image_name))
garden.document.append(gfile)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="保存文件失败")
image_id = gfile.id
data = {"filename": image_name, "uperson": user.real_name, "id": image_id}
return jsonify(code=RET.OK, msg="保存成功", data=data)
# 获取园区图片列表
@api_manage.route("/listImage", methods=["POST"])
# @login_required
def list_img():
# user_id = g.user_id
req_dict = request.get_json()
id = req_dict.get('id') # 园区id
try:
garden = Garden.query.get(id)
docs = garden.document
data = [{"id": i.id,
"url": pro_url + "/image/" + i.name,
} for i in docs if i.cate == 2]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
# db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
apps/manage/__init__.py 0 → 100644
from flask import Blueprint
api_power = Blueprint("api_power", __name__)
from . import view_org # 组织架构
from . import view_user # 用户列表
from . import view_auth # 角色、添加管理员
from . import view_dict # 字典
'''
角色权限管理、数据字典管理需要超级管理员操作，其他的只需验证登录即可
'''
apps/manage/view_auth.py 0 → 100644
import re
from flask import request, jsonify, current_app
from apps.manage import api_power
from apps.models import *
from apps.util import login_required, verify_btoken
from apps.utils.response_code import RET
# 新增角色
@api_power.route("/addRole", methods=["POST"])
@login_required
def add_role():
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
role_name = req_dict.get("role_name") # 职位名称（角色）
rolev = req_dict.get("rolev") # 权值 0层级123， 1调度，2审核，3删除，4审核/上报，5新增/编辑 ,300001"
info = req_dict.get("info") # 职位功能（角色）
# 校验参数完整性
if not all([role_name, rolev, info]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
role = Role.query.filter_by(role_name=role_name).first()
if role:
return jsonify(code=RET.DATAEXIST, msg="角色名已存在")
role = Role.query.filter_by(role=rolev).first()
if role:
return jsonify(code=RET.DATAEXIST, msg="权限配置已存在,角色：{}".format(role.role_name))
role = Role(role_name=role_name, role=rolev, info=info)
db.session.add(role)
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 获取角色列表
@api_power.route("/roles", methods=["GET"])
@login_required
def roles():
try:
roles = Role.query.all()
data = [{"id": role.id,
"name": role.role_name,
"rolev": role.role,
"info": role.info} for role in roles]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 获取角色信息
@api_power.route("/getRole", methods=["POST"])
@login_required
def roleinfo():
req_dict = request.get_json()
_id = req_dict.get("id") # 角色id
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
role = Role.query.get(_id)
data = {"id": role.id,
"name": role.role_name,
"rolev": role.role,
"info": role.info}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 角色编辑
@api_power.route("/updateRole", methods=["POST"])
@login_required
def update_role():
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get("id") # 角色id
role_name = req_dict.get("role_name") # 职位名称（角色）
rolev = req_dict.get("rolev") # 权值 1调度，2审核，3删除，4审核/上报，5新增/编辑 "00001"
info = req_dict.get("info") # 职位功能（角色）
# 校验参数完整性
if not all([_id, role_name, rolev, info]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
me = Role.query.get(_id)
if me.role_name != role_name:
role = Role.query.filter_by(role_name=role_name).first()
if role:
return jsonify(code=RET.DATAEXIST, msg="角色名已存在")
if me.role != rolev:
role = Role.query.filter_by(role=rolev).first()
if role:
return jsonify(code=RET.DATAEXIST, msg="权限配置已存在,角色：{}".format(role.role_name))
me.role_name = role_name
me.role = rolev
me.info = info
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 删除角色
@api_power.route("/deleteRole", methods=["POST"])
@login_required
def delete_role():
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get("id") # 角色id
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
me = Role.query.get(_id)
if len(me.users) != 0:
return jsonify(code=RET.DATAEXIST, msg="当前角色存在用户使用,请查证并清除后再操作")
db.session.delete(me)
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 新添管理员账号
@api_power.route("/addManager", methods=["POST"])
@login_required
def add_manager():
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
account = req_dict.get("account") # 账户
password = req_dict.get("password") # 密码
role = req_dict.get("role") # 角色 1超级管理员，2系统运维员
# 校验参数完整性
if not all([account, password, role]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 用户名唯一(字母开头，长度4-15)
try:
patten = "^[a-zA-Z][\w]*[\w]*$"
if re.match(patten, account) and re.match(patten, account).string == account:
user = Bstage.query.filter_by(name=account).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="用户名已存在")
else:
return jsonify(code=RET.DATAERR, msg="用户名格式错误1")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="用户名格式错误2")
try:
me = Bstage(name=account, role=role)
me.password = password
db.session.add(me)
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
apps/manage/view_dict.py 0 → 100644
from flask import current_app, request, jsonify
from apps.manage import api_power
from apps.models import *
from apps.util import login_required, verify_btoken
from apps.utils.response_code import RET
# 导航目录列表
@api_power.route('/listField', methods=['GET'])
@login_required
def list_fields():
'''导航目录列表'''
try:
field = Industry.query.all()
data = [{"id": i.id,
"name": i.name,
"statu": i.statu, # 启用状态1启用，2禁用
"cate": "一级产业" if i.fid == 0 else "二级产业"} for i in field]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 导航信息编辑
@api_power.route('/modifyFields', methods=['POST'])
@login_required
def modify_fields():
'''导航信息修改'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
name = req_dict.get("newname") # 行业新名字
try:
field = Industry.query.get(_id)
field.name = name
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
# 导航状态修改
@api_power.route('/fieldStatu', methods=['POST'])
@login_required
def field_statu():
'''导航信息修改'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
statu = req_dict.get("statu") # 状态值1启用，2禁用
try:
field = Industry.query.get(_id)
if statu == 1:
field.statu = 2
else:
field.statu = 1
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
'''导航一'''
# 产业发展图谱目录列表
@api_power.route('/listPropertyty', methods=['GET'])
@login_required
def list_propertyty():
'''产业发展图谱目录列表'''
try:
field = Propertyty.query.all()
data = [{"id": i.id,
"name": i.name,
"statu": i.statu, # 状态 1启动，2禁用
"cate": "企业类型" if i.sid == 1 else "企业资质" if i.sid == 2 else "上市状态" if i.sid == 3
else "融资轮次"} for i in field]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 产业发展图谱目录信息编辑
@api_power.route('/modifyPropertyty', methods=['POST'])
@login_required
def modify_propertyty():
'''产业发展图谱目录信息编辑'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
name = req_dict.get("newname") # 行业新名字
try:
propertyty = Propertyty.query.get(_id)
propertyty.name = name
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
# 产业发展图谱导航状态修改
@api_power.route('/propertytyStatu', methods=['POST'])
@login_required
def propertyty_statu():
'''产业发展图谱导航状态修改'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
statu = req_dict.get("statu") # 状态值1启用，2禁用
try:
propertyty = Propertyty.query.get(_id)
if statu == 1:
propertyty.statu = 2
else:
propertyty.statu = 1
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
'''导航二'''
# 产业招商地图360企业画像目录列表
@api_power.route('/listProperty', methods=['GET'])
@login_required
def list_property():
'''产业发展图谱目录列表'''
try:
propert = Property.query.all()
data = [{"id": i.id,
"name": i.name,
"statu": i.statu, # 状态 1启动，2禁用
"cate": "企业类型" if i.sid == 1 else "企业资质" if i.sid == 2 else "上市状态" if i.sid == 3
else "融资轮次"} for i in propert]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 产业招商地图360企业画像目录信息编辑
@api_power.route('/modifyProperty', methods=['POST'])
@login_required
def modify_property():
'''产业招商地图360企业画像目录信息编辑'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
name = req_dict.get("newname") # 行业新名字
try:
propert = Property.query.get(_id)
propert.name = name
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
# 产业招商地图360企业画像目录状态修改
@api_power.route('/propertyStatu', methods=['POST'])
@login_required
def property_statu():
'''产业招商地图360企业画像目录状态修改'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
statu = req_dict.get("statu") # 状态值1启用，2禁用
try:
propert = Property.query.get(_id)
if statu == 1:
propert.statu = 2
else:
propert.statu = 1
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
'''导航三'''
# 招商资源管理目录列表
@api_power.route('/listAttract', methods=['GET'])
@login_required
def list_atract():
'''招商资源管理目录列表'''
try:
attract = Attract.query.all()
data = [{"id": i.id,
"name": i.name,
"statu": i.statu, # 状态 1启动，2禁用
"cate": "行业选择" if i.sid == 1 else "项目阶段" if i.sid == 2 else "项目级别"} for i in attract]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 招商资源管理目录信息编辑
@api_power.route('/modifyAttract', methods=['POST'])
@login_required
def modify_attract():
'''招商资源管理目录信息编辑'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
name = req_dict.get("newname") # 行业新名字
try:
attract = Attract.query.get(_id)
attract.name = name
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
# 招商资源管理目录状态修改
@api_power.route('/attractStatu', methods=['POST'])
@login_required
def attract_statu():
'''产业发展图谱导航状态修改'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
statu = req_dict.get("statu") # 状态值1启用，2禁用
try:
attract = Attract.query.get(_id)
if statu == 1:
attract.statu = 2
else:
attract.statu = 1
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
'''导航四'''
# 园区信息目录列表
@api_power.route('/listZone', methods=['GET'])
@login_required
def list_zone():
'''招商资源管理目录列表'''
try:
zone = Zone.query.all()
data = [{"id": i.id,
"name": i.name,
"statu": i.statu, # 状态 1启动，2禁用
"cate": "园区类别" if i.sid == 1 else "园区级别"} for i in zone]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 园区信息目录信息编辑
@api_power.route('/modifyZone', methods=['POST'])
@login_required
def modify_zone():
'''园区信息目录信息编辑'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
name = req_dict.get("newname") # 行业新名字
try:
zone = Zone.query.get(_id)
zone.name = name
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
# 园区信息目录状态修改
@api_power.route('/zoneStatu', methods=['POST'])
@login_required
def zone_statu():
'''园区信息目录状态修改'''
token = request.headers["token"]
user = verify_btoken(token)
user_role = user.role # 用户角色
if user_role != 1:
return jsonify(code=RET.ROLEERR, msg="暂无权限")
req_dict = request.get_json()
_id = req_dict.get('id') # 行业id
statu = req_dict.get("statu") # 状态值1启用，2禁用
try:
zone = Zone.query.get(_id)
if statu == 1:
zone.statu = 2
else:
zone.statu = 1
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="修改成功")
apps/manage/view_org.py 0 → 100644
from flask import request, jsonify, current_app, g
from apps.manage import api_power
from apps.models import *
from apps.utils.response_code import RET
from apps.util import login_required
# 获取上级或下级统筹机构 (ok)
@api_power.route("/uadOrg", methods=["GET"])
@login_required
def uad_org():
try:
gover = Government.query.all()
data = [{"label": i.name, "value": i.id} for i in gover]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 获取上级机构后的统筹机构 (ok)
@api_power.route("/downOrg", methods=["POST"])
@login_required
def down_org():
req_dict = request.get_json()
_id = req_dict.get("id") # 机构名称
try:
if _id:
gover = Government.query.all()
data = [{"label": i.name, "value": i.id} for i in gover if i.id != _id]
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
gover = Government.query.all()
data = [{"label": i.name, "value": i.id} for i in gover]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 新增机构组织（ok）
@api_power.route("/addOrg", methods=["POST"])
@login_required
def add_org():
'''
不得重名
'''
req_dict = request.get_json()
name = req_dict.get("name") # 机构名称
forg = req_dict.get("forg") # 上级机构 id
charge = req_dict.get("charge") # 机构负责人
charge_phone = req_dict.get("charge_phone") # 负责人电话
sublist = req_dict.get("sublist") # 统筹机构id list["1","2"...]
# 校验参数完整性
if not all([name]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
gover = Government.query.filter_by(name=name).first()
if gover: # 机构名相同，提示其错误
return jsonify(code=RET.DBERR, msg="机构名重复")
goverment = Government(name=name) # 创建机构
if charge:
goverment.charge = charge
if charge_phone:
goverment.charge_phone = charge_phone
db.session.add(goverment) # 添加到数据库
if forg: # 如果有上级机构，就让上级机构统筹新增机构
fgover = Government.query.get(forg)
fgover.followed.append(goverment)
for ctr in sublist: # 如果有统筹机构，就让新增机构统筹
sgover = Government.query.get(ctr)
goverment.followed.append(sgover)
db.session.commit() # 提交数据库
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 组织架构管理,获取机构单位数据（ok）
@api_power.route("/organization", methods=["POST"])
@login_required
def organization():
req_dict = request.get_json()
page = req_dict.get("page")
perpage = req_dict.get("perpage")
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
# goverment = Government.query.paginate(page, perpage).items
goverment = Government.query.all()
size = Government.query.count()
df = [{"id": gover.id,
"name": gover.name,
"pnums": gover.pnums if gover.pnums else 0,
"charge": gover.charge if gover.charge else "-",
"charge_phone": gover.charge_phone if gover.charge_phone else "-",
"cate": 1} for gover in goverment]
data = {"df": df, "size": size}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
# 组织架构获取部门和组（Ok）
@api_power.route("/sectionGroup", methods=["POST"])
@login_required
def section_group():
req_dict = request.get_json()
_id = req_dict.get("id") # 当前机构或者部门的id
cate = req_dict.get("cate") # 分类标识，1机构，2部门
# 校验参数完整性
if not all([_id, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 查询当前机构下的部门
goverment = Government.query.get(_id)
sections = goverment.sections # 查询当前机构下的部门list
data = [{"id": sec.id,
"name": sec.name,
"pnums": sec.pnums if sec.pnums else 0,
"charge": sec.charge if sec.charge else "-",
"charge_phone": sec.charge_phone if sec.charge_phone else "-",
"cate": 2} for sec in sections]
return jsonify(code=RET.OK, msg="查找成功", data=data)
if cate == 2: # 查询当前部门下的组
section = Section.query.get(_id)
groups = section.groups # 查询当前部门下的组list
data = [{"id": group.id,
"name": group.name,
"pnums": group.pnums if group.pnums else 0,
"charge": group.charge if group.charge else "-",
"charge_phone": group.charge_phone if group.charge_phone else "-",
"cate": 3} for group in groups]
return jsonify(code=RET.OK, msg="查找成功", data=data)
return jsonify(code=RET.OK, msg="暂无下级信息", data=[])
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误", data=[])
# 新增下级部门(ok)
@api_power.route("/addSub", methods=["POST"])
@login_required
def add_sub():
req_dict = request.get_json()
_id = req_dict.get("id") # 当前机构或者部门id
cate = req_dict.get("cate") # 分类标识，1机构，2部门
name = req_dict.get("name") # 部门或组名称
pnums = req_dict.get("pnums") # 机构负责人
charge = req_dict.get("charge") # 机构负责人
charge_phone = req_dict.get("charge_phone") # 负责人电话
# 校验参数完整性
if not all([_id, cate, name]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 增加部门
sec = Section.query.filter_by(name=name, goverment_id=_id).first()
if sec: # 一个机构下部门名不能重复
return jsonify(code=RET.DATAERR, msg="部门名重复")
goverment = Government.query.get(_id)
section = Section(name=name, goverment_id=_id)
if pnums:
section.pnums = pnums
if charge:
section.charge = charge
if charge_phone:
section.charge_phone = charge_phone
db.session.add(section) # 添加部门
goverment.sections.append(section) # 外键关系添加
db.session.commit() # 数据库提交
if cate == 2: # 增加组
gro = Group.query.filter_by(name=name, section_id=_id).first()
if gro: # 一个部门下组名不能重复
return jsonify(code=RET.DATAERR, msg="组名重复")
section = Section.query.get(_id)
group = Group(name=name, section_id=_id)
if pnums:
group.pnums = pnums
if charge:
group.charge = charge
if charge_phone:
group.charge_phone = charge_phone
db.session.add(group) # 添加组
section.groups.append(group) # 添加关系
db.session.commit() # 提交
if cate == 3:
return jsonify(code=RET.OK, msg="暂无下级机构，请勿继续添加")
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
# 操作失败，数据回滚
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 删除组织机构或者部门和组(需要先删除人员)--------OK
@api_power.route("/deleteOrg", methods=["POST"])
@login_required
def deleteorg():
req_dict = request.get_json()
_id = req_dict.get("id") # 待删除的，部门、机构、组、id
cate = req_dict.get("cate") # 待删除数据的类别 1政府，2部门，3组
# 校验参数完整性
if not all([_id, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 删除机构
gover = Government.query.get(_id) # 当前机构对象
section = gover.sections # 当前机构下的部门对象列表
if len(section) > 0: # 有部门就需要先删除部门
return jsonify(code=RET.REQERR, msg="当前机构有部门存在，请清除后再操作")
unums = User.query.filter_by(unit=gover.name, status=1).count() # 当前机构下通过审核人员
if unums > 0: # 当前部门有人，先到机构详情，进行人员的删除
return jsonify(code=RET.REQERR, msg="当前机构有人员存在，请清除后再操作")
db.session.delete(gover) # 无人无部门，删除
db.session.commit() # 提交
return jsonify(code=RET.OK, msg="删除成功")
if cate == 2: # 删除部门
section = Section.query.get(_id)
gover = section.goverment # 部门所属的机构
group = section.groups # 当前部门的组对象list
if len(group) > 0: # 如果有组先删除组
return jsonify(code=RET.REQERR, msg="当前部门有组存在，请清除后再操作")
unums = User.query.filter_by(unit=gover.name, section=section.name, status=1).count() # # 已经通过审核的人数
if unums > 0: # 当前部门有人，先到部门详情，进行部门人员的删除
return jsonify(code=RET.REQERR, msg="当前部门有人员存在，请清除后再操作")
gover.sections.remove(section) # 当前部门没有人，没有组，删除部门之前需要先删除与之相关的机构关系
db.session.delete(section) # 删除
db.session.commit() # 提交
return jsonify(code=RET.OK, msg="删除成功")
if cate == 3: # 删除组
group = Group.query.get(_id) # 当前组信息
section = group.section # 组属于的部门，单个对象
gover = section.goverment # 部门属于的机构，单个对象
unums = User.query.filter_by(unit=gover.name, section=section.name, group=group.name,
status=1).count() # 已经通过审核的人数
if unums > 0: # 当前组有人，先到组详情，进行组员的删除
return jsonify(code=RET.REQERR, msg="当前组有人员存在，请清除后再操作")
section.groups.remove(group) # 当前组没有人，删除组之前需要先删除与之相关的部门关系
db.session.delete(group) # 删除
db.session.commit() # 提交
return jsonify(code=RET.OK, msg="删除成功")
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作失败")
''''''
# 获取机构，部门或者组详情()
@api_power.route("/orgDetail", methods=["POST"])
@login_required
def org_detail():
req_dict = request.get_json()
_id = req_dict.get("id") # id
cate = req_dict.get("cate") # 1机构，2部门，3组
# 校验参数完整性
if not all([_id, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 政府机构详情
goverment = Government.query.get(_id)
# 政府信息
data = {"id": goverment.id,
"name": goverment.name, # 机构名
"charge": goverment.charge if goverment.charge else "-", # 主管
"phone": goverment.charge_phone if goverment.charge_phone else "-", # 电话
"pnums": goverment.pnums if goverment.pnums else 0, # 机构人数
"secnums": len(goverment.sections), # 部门数
"func": goverment.function if goverment.function else "", # 政府职能
"cate": cate}
return jsonify(code=RET.OK, msg="查询成功", data=data)
if cate == 2: # 部门详情
section = Section.query.get(_id)
# 政府信息
data = {"id": section.id,
"name": section.name, # 机构名
"charge": section.charge if section.charge else "-", # 主管
"phone": section.charge_phone if section.charge_phone else "-", # 电话
"pnums": section.pnums if section.pnums else 0, # 机构人数
"secnums": len(section.groups), # 组数
"func": section.function if section.function else "", # 部门职能
"cate": cate}
return jsonify(code=RET.OK, msg="查询成功", data=data)
if cate == 3: # 组详情
group = Group.query.get(_id)
# 政府信息
data = {"id": group.id,
"name": group.name, # 机构名
"charge": group.charge if group.charge else "-", # 主管
"phone": group.charge_phone if group.charge_phone else "-", # 电话
"pnums": group.pnums if group.pnums else 0, # 机构人数
"secnums": "-",
"func": group.function if group.function else "", # 部门职能
"cate": cate}
return jsonify(code=RET.OK, msg="查询成功", data=data)
return jsonify(code=RET.OK, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 编辑机构，部门或者组详情
@api_power.route("/editDetail", methods=["POST"])
@login_required
def edit_detail():
req_dict = request.get_json()
_id = req_dict.get("id") # 部门id
cate = req_dict.get("cate") # 1机构，2部门，3组
name = req_dict.get("name") # 1机构，2部门，3组 的名称
charge = req_dict.get("charge") # 局内领导
charge_phone = req_dict.get("charge_phone") # 联系方式
func = req_dict.get("func") # 部门职能
pnums = str(req_dict.get("pnums")) # 人数
secnums = str(req_dict.get("secnums")) # 部门组人数
# 校验参数完整性
if not all([_id, name, charge, charge_phone, pnums, secnums]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 机构
gover = Government.query.filter_by(name=name).filter(Government.id != _id).first()
if gover:
return jsonify(code=RET.DBERR, msg="机构名不可重复")
gover = Government.query.get(_id)
gover.name = name
gover.charge = charge
gover.charge_phone = charge_phone
gover.function = func
gover.pnums = pnums
gover.secnums = secnums
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
if cate == 2: # 部门
section = Section.query.get(_id) # 当前部门
gover_id = section.goverment_id # 当前部门的机构id
sec = Section.query.filter_by(name=name, goverment_id=gover_id).filter(Section.id != _id).first()
if sec: # 当前机构下此部门名已存在
return jsonify(code=RET.DBERR, msg="部门名不可重复")
section.name = name
section.charge = charge
section.charge_phone = charge_phone
section.function = func
section.pnums = pnums
section.secnums = secnums
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
if cate == 3: # 组
group = Group.query.get(_id) # 当前组
sec_id = group.section_id # 当前组的部门id
gro = Group.query.filter_by(name=name, section_id=sec_id).filter(Group.id != _id).first()
if gro: # 当前部门下此组名已存在
return jsonify(code=RET.DBERR, msg="组名不可重复")
group.name = name
group.charge = charge
group.charge_phone = charge_phone
group.function = func
group.pnums = pnums
group.secnums = secnums
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
return jsonify(code=RET.DATAERR, msg="cate参数错误")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 获取机构，部门或者组的人员
@api_power.route("/orgStaff", methods=["POST"])
@login_required
def org_staff():
req_dict = request.get_json()
_id = req_dict.get("id") # 部门id
cate = req_dict.get("cate") # 1机构，2部门，3组
# 校验参数完整性
if not all([_id, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 政府机构详情
goverment = Government.query.get(_id)
# 人员列表
staff = User.query.filter_by(status=1, unit=goverment.name).filter(User.role_id.isnot(None)).all() # 通过审核的员工列表
staff = [{"id": i.id,
"name": i.real_name,
"position": i.position,
"section": i.section} for i in staff]
return jsonify(code=RET.OK, msg="查询成功", data=staff)
if cate == 2: # 部门详情
section = Section.query.get(_id)
# 人员列表
staff = User.query.filter_by(status=1, unit=section.goverment.name, section=section.name).filter(User.role_id.isnot(None)).all() # 通过审核的员工列表
staff = [{"id": i.id,
"name": i.real_name,
"position": i.position,
"section": i.section} for i in staff]
return jsonify(code=RET.OK, msg="查询成功", data=staff)
if cate == 3: # 组详情
group = Group.query.get(_id)
# 人员列表
staff = User.query.filter_by(status=1, unit=group.section.goverment.name, section=group.section.name,
group=group.name).filter(User.role_id.isnot(None)).all() # 通过审核的员工列表
staff = [{"id": i.id,
"name": i.real_name,
"position": i.position,
"section": i.section} for i in staff]
return jsonify(code=RET.OK, msg="查询成功", data=staff)
else:
return jsonify(code=RET.OK, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 机构部门或这组的待新增人员列表-------------------?
@api_power.route("/listOfStaff", methods=["POST"])
# @login_required
def list_Staff():
req_dict = request.get_json()
_id = req_dict.get("id") # 当前机构id
cate = req_dict.get("cate") # 1机构 2部门 3组
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 政府
gover = Government.query.get(_id)
if gover:
name = gover.name
user = User.query.filter_by(unit=name).filter(User.role_id.isnot(None)).all()
data = [{"id": i.id,
"real_name": i.real_name if i.real_name else i.id} for i in user]
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
if cate == 2: # 部门
section = Section.query.get(_id)
if section:
gover = section.goverment
user = User.query.filter_by(unit=gover.name).filter(User.role_id.isnot(None)).all()
data = [{"id": i.id,
"real_name": i.real_name if i.real_name else i.id} for i in user]
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
if cate == 3: # 组
group = Group.query.get(_id)
if group:
section = group.section
gover = section.goverment
user = User.query.filter_by(unit=gover.name).filter(User.role_id.isnot(None)).all()
data = [{"id": i.id,
"real_name": i.real_name if i.real_name else i.id} for i in user]
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 机构部门或这组的人员 新增（人员部门调度）
@api_power.route("/addStaffOrg", methods=["POST"])
# @login_required
def add_staff():
req_dict = request.get_json()
_id = req_dict.get("id") # 部门机构组id
cate = req_dict.get("cate") # 1政府，2部门，3组
uid = req_dict.get("uid") # 员工id
level = req_dict.get("level") # 职级(角色id)
position = req_dict.get("position") # 职务,文本框随意填
# 校验参数完整性
if not all([_id, level, position]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.get(uid)
if user:
if cate == 1: # 政府机构
user.section = Government.query.get(_id).name
# 删除原有角色
role = Role.query.get(user.role_id)
role.users.remove(user)
# 添加新角色
role = Role.query.get(level)
role.users.append(user)
user.position = position
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
if cate == 2: # 部门调度
user.section = Section.query.get(_id).name
# 删除原有角色
role = Role.query.get(user.role_id)
role.users.remove(user)
# 添加新角色
role = Role.query.get(level)
role.users.append(user)
user.position = position
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
if cate == 3: # 组调度
user.group = Group.query.get(_id).name
# 删除原有角色
role = Role.query.get(user.role_id)
role.users.remove(user)
# 添加新角色
role = Role.query.get(level)
role.users.append(user)
user.position = position
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
return jsonify(code=RET.DATAERR, msg="参数错误")
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# # 测试
# @api_power.route("/cs", methods=["get"])
# def ces():
# gover = Government.query.get(18)
# section = Section.query.get(37)
# print(gover,section)
# # section.goverment.remove(gover)
# gover.sections.remove(section)
# db.session.commit()
# return "ok"
''''''
# 机构部门或这组的人员 删除（人员失去组，机构项目）
@api_power.route("/deleteStaffOrg", methods=["POST"])
@login_required
def delete_staff():
req_dict = request.get_json()
uid = req_dict.get("uid") # 员工id
cate = req_dict.get("cate") # 1政府，2部门，3组
_id = req_dict.get("id") # 机构部门组id
# level = req_dict.get("level") # 职级
# position = req_dict.get("position") # 职务
# 校验参数完整性
if not all([uid, cate, _id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.get(uid)
if user:
if cate == 1: # 政府机构
role = Role.query.get(user.role_id)
role.users.remove(user)
user.unit = "" # 机构
user.position = "" # 职位
user.section = "" # 部门
user.group = "" # 组
user.level = "" # 级别
user.leader = "" # 领导者
user.password = "" # 密码
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
if cate == 2: # 部们
role = Role.query.get(user.role_id)
# user.role_id = ""
role.users.remove(user)
user.position = ""
user.section = ""
user.group = ""
user.level = ""
# user.role_id = ""
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
if cate == 3: # 组调度
user.group = ""
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
return jsonify(code=RET.DATAERR, msg="参数错误")
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 获取统筹机构列表
@api_power.route("/orgCtrl", methods=["POST"])
@login_required
def org_ctrl():
req_dict = request.get_json()
_id = req_dict.get("id") # 机构id
cate = req_dict.get("cate") # 1政府，2部门，3组
# 校验参数完整性
if not all([_id, cate]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == 1: # 政府机构详情
goverment = Government.query.get(_id)
# 统筹机构列表
ctrl = goverment.followed
bkpm = [{"id": j.id,
"name": j.name,
"charge": j.charge if j.charge else "-",
"phone": j.charge_phone if j.charge_phone else "-"} for j in ctrl]
return jsonify(code=RET.OK, msg="查询成功", data=bkpm)
return jsonify(code=RET.OK, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 获取待新增统筹机构列表
@api_power.route("/getCtrl", methods=["POST"])
@login_required
def get_ctrl():
req_dict = request.get_json()
_id = req_dict.get("id")
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
goverment = Government.query.get(_id)
folllowedids = {i.id for i in goverment.followed} # 已经被管制的
folllowedids.add(_id) # 添加自己
all_ids = {i.id for i in Government.query.filter_by().all()} # 全部机构id
options = list(all_ids - folllowedids) # 未被当前机构统筹的机构id列表
goverments = Government.query.filter(Government.id.in_(options)).all()
data = [{"id": i.id,
"name": i.name} for i in goverments]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="添加失败")
# 机构详情页添加统筹机构
@api_power.route("/addBeCtrl", methods=["POST"])
@login_required
def add_bectrl():
req_dict = request.get_json()
_id = req_dict.get("id")
ids = req_dict.get("ids")
# 校验参数完整性
if not all([_id, ids]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
goverment = Government.query.get(_id)
folllowedids = {i.id for i in goverment.followed}
ids = set(ids)
for id in (ids - folllowedids):
gover = Government.query.get(id)
goverment.followed.append(gover)
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="添加失败")
# 机构详情页删除统筹机构
@api_power.route("/deleteCtrl", methods=["POST"])
@login_required
def delete_bectrl():
req_dict = request.get_json()
_id = req_dict.get("id")
bectrl_id = req_dict.get("bectrl_id")
# 校验参数完整性
if not all([_id, bectrl_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
goverment = Government.query.get(_id)
begoverment = Government.query.get(bectrl_id)
goverment.followed.remove(begoverment)
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
except Exception as e:
# 操作失败，回滚数据库
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作失败")
apps/manage/view_user.py 0 → 100644
import re
from flask import request, jsonify, current_app
from sqlalchemy import func, desc, or_, and_
from apps.manage import api_power
from apps.models import *
from apps.utils.response_code import RET
from apps.util import login_required
# 外部访客列表
@api_power.route("/userListOfExternal", methods=["POST"])
@login_required
def user_list_external():
req_dict = request.get_json()
page = req_dict.get("page")
perpage = req_dict.get("perpage")
key = req_dict.get("key") # 查询条件
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.filter_by(flag=1)
if key:
user = user.filter(User.name.like("%{}%".format(key)))
result = user.paginate(page, perpage).items
size = user.count()
df = [{"id": i.id,
"real_name": i.real_name if i.real_name else "-",
"name": i.name if i.name else "-",
"mobile": i.mobile if i.mobile else "-",
"age": i.age if i.age else "-",
"sex": "男" if i.sex == 1 else "女" if i.sex == 2 else "-",
"create_time": str(i.create_time) if i.create_time else "-",
"email": i.email if i.email else "-",
"status": i.status} for i in result] # 1启用,2禁止
data = {"df": df, "size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 外部访客状态修改
@api_power.route("/updateStatus", methods=["POST"])
@login_required
def update_status():
req_dict = request.get_json()
_id = req_dict.get("id")
status = req_dict.get("status") # 1通过 2禁用
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.get(_id)
if status == 1:
user.status = 3
else:
user.status = 1
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Exception as e:
# 操作失败，操作返回
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 局内用户筛选条件
@api_power.route("/manage/fields", methods=["GET"])
def manage_field():
''''''
try:
gover = Government.query.all()
data = {"status": [{"label": "通过", "value": 1}, {"label": "在审", "value": 2}, {"label": "驳回", "value": 3}],
"goverment": [{"label": i.name, "value": i.id} for i in gover]}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 局内用户筛选条件2, 根据机构获取部门
@api_power.route("/manage/fieldt", methods=["POST"])
def manage_fielt():
''''''
req_dict = request.get_json()
_id = req_dict.get("id") # 机构id
try:
gover = Government.query.get(_id)
section = gover.sections
data = [{"label": i.name, "value": i.id} for i in section]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
# 局内用户列表
@api_power.route("/userListOfInside", methods=["POST"])
# @login_required
def user_list_inside():
req_dict = request.get_json()
page = req_dict.get("page")
perpage = req_dict.get("perpage")
key = req_dict.get("key") # 查询条件
status = req_dict.get("status") # 1通过，2在审，3驳回
unit = req_dict.get("unit") # 所在机构id
section = req_dict.get("section") # 所在部门id
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.filter_by(flag=2)
if key:
# user = user.filter(User.real_name.like("%{}%".format(key)))
user = user.filter(or_(User.real_name.like("%{}%".format(key)), User.name.like("%{}%".format(key))))
if status:
user = user.filter_by(status=status)
if unit:
unit_name = Government.query.get(unit).name
user = user.filter_by(unit=unit_name)
if section:
sec_name = Section.query.get(section).name
user = user.filter_by(section=sec_name)
size = user.count()
result = user.paginate(page, perpage).items
df = [{"id": i.id,
"real_name": i.real_name if i.real_name else "-",
"position": i.position if i.position else "-",
"level": i.level if i.level else "-",
"unit": i.unit if i.unit else "-",
"section": i.section if i.section else "-",
"leader": i.leader if i.leader else "-",
"mobile": i.mobile if i.mobile else "-",
"age": i.age if i.age else "-",
"sex": "男" if i.sex == 1 else "女" if i.sex == 2 else "-",
"email": i.email if i.email else "-",
"name": i.name if i.name else "-",
"create_time": str(i.create_time) if i.create_time else "-",
"status": "通过" if i.status == 1 else "在审" if i.status == 2 else "驳回"} for i in result]
data = {"df": df, "size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 局内用户信息
@api_power.route("/userInsideInfo", methods=["POST"])
@login_required
def user_inside_info():
req_dict = request.get_json()
_id = req_dict.get("id")
try:
i = User.query.get(_id)
data = {"id": i.id,
"real_name": i.real_name if i.real_name else "-",
"position": i.position if i.position else "-",
"level": "", # 角色
"unit": "", # 机构
"section": "", # 部门
"leader": i.leader if i.leader else "-",
"mobile": i.mobile if i.mobile else "-",
"age": i.age if i.age else "-",
"sex": "男" if i.sex == 1 else "女" if i.sex == 2 else "-",
"email": i.email if i.email else "",
"name": i.name if i.name else "-",
"create_time": str(i.create_time) if i.create_time else "-",
"status": "通过" if i.status == 1 else "在审" if i.status == 2 else "驳回"}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 局内用户编辑
@api_power.route("/updateUser", methods=["POST"])
@login_required
def update_user():
req_dict = request.get_json()
_id = req_dict.get("id") # 当亲用户id
real_name = req_dict.get("real_name") # 真名
position = req_dict.get("position") # 职务
level = req_dict.get("level") # 角色id 必选
unit = req_dict.get("unit") # 机构
section = req_dict.get("section") # 部门
leader = req_dict.get("leader") # 领导
mobile = req_dict.get("mobile")
sex = req_dict.get("sex") # 1男2女
age = req_dict.get("age")
email = req_dict.get("email")
name = req_dict.get("name")
password = req_dict.get("name")
# 用户名唯一(字母开头，长度4-15)
try:
patten = "^[a-zA-Z][\w]*[\w]*$"
if re.match(patten, name) and re.match(patten, name).string == name:
user = User.query.filter_by(name=name).filter(User.id != _id).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="用户名已存在")
else:
return jsonify(code=RET.DATAERR, msg="用户名格式错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="用户名格式错误")
# 校验参数完整性
if not all([_id, real_name, position, level, leader, mobile, sex, age, name]):
return jsonify(code=RET.PARAMERR, msg="请选择必填项")
try:
role = Role.query.get(level)
user = User.query.get(_id)
user.real_name = real_name
user.position = position
user.level = role.role_name
if unit:
user.unit = Government.query.get(unit).name
if section:
user.section = Section.query.get(section).name
user.leader = leader
user.mobile = mobile
user.sex = sex
user.age = age
if email:
user.email = email
user.name = name
if password:
user.password = password
role.users.append(user)
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 局内用户新增
@api_power.route("/addUser", methods=["POST"])
# @login_required
def add_user():
req_dict = request.get_json()
real_name = req_dict.get("real_name") # 真实姓名
position = req_dict.get("position") # 职务
level = req_dict.get("level") # 职级 id (角色id)
unit = req_dict.get("unit") # 机构id
section = req_dict.get("section") # 部门id
leader = req_dict.get("leader") # ?
mobile = req_dict.get("mobile")
sex = req_dict.get("sex") # 1男2女
age = req_dict.get("age")
email = req_dict.get("email")
name = req_dict.get("name")
password = req_dict.get("password")
# 校验参数完整性
if not all([real_name, position, unit, mobile, sex, name, password]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 用户名唯一(字母开头，长度4-15)
try:
patten = "^[a-zA-Z][\w]*[\w]*$"
if re.match(patten, name) and re.match(patten, name).string == name:
user = User.query.filter_by(name=name).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="用户名已存在")
else:
return jsonify(code=RET.DATAERR, msg="用户名格式错误,请填入以字母开头的数字和字母组合")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="用户名格式错误")
# 判断手机号
try:
user = User.query.filter_by(mobile=mobile).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="手机号已存在")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="手机号已存在")
try:
role = Role.query.get(level)
govername = Government.query.get(unit) # 获取机构name
user = User(real_name=real_name, age=age, sex=sex, mobile=mobile, unit=govername.name, position=position,
name=name, flag=2, status=1, level=role.role_name)
user.password = password
if section: # 部门id
secname = Section.query.get(section).name # 获取部门名
user.section = secname
if leader: # 领导
user.leader = leader
if email: # 邮箱
user.email = email
db.session.add(user)
role.users.append(user)
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 编辑状态
@api_power.route("/updateAccount", methods=["POST"])
@login_required
def update_account():
req_dict = request.get_json()
_id = req_dict.get("id")
status = req_dict.get("status") # 1通过，2在审，3驳回
# 校验参数完整性
if not all([_id, status]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.get(_id)
if not user.role and status == 1: # 没有角色，想通过
return jsonify(code=RET.DATAERR, msg="请先在编辑，为用户添加职级角色")
user.status = status
db.session.commit()
dict_zh = {1: "通过", 2: "在审", 3: "驳回"}
data = dict_zh[status]
return jsonify(code=RET.OK, msg="修改成功", info=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 删除用户(批量删除，单个删除)
@api_power.route("/deleteUser", methods=["POST"])
@login_required
def delete_user():
req_dict = request.get_json()
ids = req_dict.get("id") # list[1,2,3]
# 校验参数完整性
if not all([ids]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
for i in ids:
user = User.query.get(i)
db.session.delete(user)
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="删除失败")
# 职级（角色）列表获取
@api_power.route("/getRole", methods=["GET"])
@login_required
def get_role():
try:
roles = Role.query.all()
data = [{"value": role.id,
"label": role.role_name} for role in roles]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库操作错误")
apps/models.py 0 → 100644
from datetime import datetime
# Werkzeug库的security实现散列密码的计算
from werkzeug.security import generate_password_hash, check_password_hash
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from apps import constants
from . import db
from config import Config
from sqlalchemy import text
class BaseModel:
"""
模型基类，补充创建时间与更新时间
"""
create_time = db.Column(db.DateTime, default=datetime.now, doc='创建时间', comment='创建时间') # 记录的创建时间
update_time = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now, doc='更新时间', comment='更新时间') # 记录的更新时间
# 全国企业
class Enterprise(db.Model):
__tablename__ = "enterprise"
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='企业主键id', comment='企业主键id主键id') # 企业
company_name = db.Column(db.String(255), index=True, doc='企业名', comment='企业名') # 企业名
status = db.Column(db.String(32), doc='经营状态', comment='经营状态') # 经营状态
legal = db.Column(db.String(255), doc='发定代表人', comment='发定代表人') # 发定代表人
capital = db.Column(db.String(255), doc='注册资本,22万美元', comment='注册资本,22万美元') # 注册资本,22万美元
capital_nums = db.Column(db.Float, doc='注册资本转换成人民币数值', comment='注册资本转换成人民币数值') # 注册资本转换成人民币数值
capital_id = db.Column(db.Integer, doc='注册资本大小类型，0-100,1,100-500,2,500-1000,3,1000-5000,4,5000-10000,5,10000+，6', comment='注册资本大小类型，0-100,1,100-500,2,500-1000,3,1000-5000,4,5000-10000,5,10000+，6') # 注册资本大小类型，0-100,1,100-500,2,500-1000,3,1000-5000,4,5000-10000,5,10000+，6
build_date = db.Column(db.DateTime, doc='注册时间', comment='注册时间') # 注册时间
yearid = db.Column(db.Integer, index=True, doc='成立时间年限id(1-3，1)(3-5，2)(5-8，3)（8-10，4）（10-15,5）（15以上，6）', comment='成立时间年限id(1-3，1)(3-5，2)(5-8，3)（8-10，4）（10-15,5）（15以上，6）') # 成立时间年限id(1-3，1)(3-5，2)(5-8，3)（8-10，4）（10-15,5）（15以上，6）
province = db.Column(db.String(32), index=True, doc='省', comment='省') # 省
city = db.Column(db.String(32), index=True, doc='市', comment='市') # 市
district = db.Column(db.String(32), index=True, doc='区', comment='区') # 区
lng = db.Column(db.String(100), doc='经度', comment='经度') # 经度
lat = db.Column(db.String(100), doc='纬度', comment='纬度') # 纬度
p_lng = db.Column(db.String(100), doc='省经度', comment='省经度') # 省经度
p_lat = db.Column(db.String(100), doc='省纬度', comment='省纬度') # 省纬度
c_lng = db.Column(db.String(100), doc='市经度', comment='市经度') # 市经度
c_lat = db.Column(db.String(100), doc='市纬度', comment='市纬度') # 市纬度
d_lng = db.Column(db.String(100), doc='区经度', comment='区经度') # 区经度
d_lat = db.Column(db.String(100), doc='区纬度', comment='区纬度') # 区纬度
address = db.Column(db.String(255), doc='企业地址', comment='企业地址') # 企业地址
telephone = db.Column(db.Text, doc='电话', comment='电话') # 电话
telephone_more = db.Column(db.Text, doc='更多电话', comment='更多电话') # 更多电话
email = db.Column(db.Text, doc='邮箱', comment='邮箱') # 邮箱
social_code = db.Column(db.String(100), doc='统一社会信用代码', comment='统一社会信用代码') # 统一社会信用代码
tax_code = db.Column(db.String(100), doc='纳税人识别号', comment='纳税人识别号') # 纳税人识别号
register_code = db.Column(db.String(100), doc='注册号', comment='注册号') # 注册号
company_code = db.Column(db.String(100), doc='组织机构代码', comment='组织机构代码') # 组织机构代码
bao_num = db.Column(db.Integer, doc='参保人数', comment='参保人数') # 参保人数
entype = db.Column(db.String(100), doc='企业类型', comment='企业类型') # 企业类型
entypeid = db.Column(db.Integer, index=True, doc='公司类型id(个人独资企业-1)(股份有限公司-2)(有限责任公司-3)(合伙企业-4)(集体所有制-5)(全民所有制企业-6)(外商企业-7)', comment='公司类型id(个人独资企业-1)(股份有限公司-2)(有限责任公司-3)(合伙企业-4)(集体所有制-5)(全民所有制企业-6)(外商企业-7)') # 公司类型id(个人独资企业-1)(股份有限公司-2)(有限责任公司-3)(合伙企业-4)(集体所有制-5)
# (全民所有制企业-6)(外商企业-7)
company_industry = db.Column(db.String(100), doc='所属行业', comment='所属行业') # 所属行业
web_site = db.Column(db.String(255), doc='企业网址', comment='企业网址') # 企业网址
business_scope = db.Column(db.Text, doc='企业经营范围', comment='企业经营范围') # 企业经营范围
money_type = db.Column(db.String(100), doc='注册币种', comment='注册币种') # 注册币种
money_type_id = db.Column(db.Integer, doc='注册币种类型id', comment='注册币种类型id') # 注册币种类型id
high_new = db.Column(db.String(32), doc='是否高新技术企业', comment='是否高新技术企业') # 是否高新技术企业
parti_year = db.Column(db.Integer, doc='高新企业注册年份', comment='高新企业注册年份') # 高新企业注册年份
tbe = db.Column(db.String(32), doc='是否科技型中小企业', comment='是否科技型中小企业') # 是否科技型中小企业
fianacing = db.Column(db.String(32), doc='是否为有融资企业', comment='是否为有融资企业') # 是否为有融资企业
fianacing_rounds = db.Column(db.String(32), doc='融资轮次', comment='融资轮次') # 融资轮次
roundid = db.Column(db.Integer, index=True, doc='融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）', comment='融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）') # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
financing_amount = db.Column(db.Float, doc='融资金额', comment='融资金额') # 融资金额
software_copyright = db.Column(db.String(32), doc='是否为有软件著作权', comment='是否为有软件著作权') # 是否为有软件著作权
num_software = db.Column(db.Integer, doc='软件著作权个数', comment='软件著作权个数') # 软件著作权个数
quoted_company = db.Column(db.String(32), doc='是否上市企业', comment='是否上市企业') # 是否上市企业
public_sector = db.Column(db.String(32), doc='上市板块', comment='上市板块') # 上市板块
public_id = db.Column(db.Integer, index=True, doc='上市版块的id----360企业画像（A股,1）(创业股，2)(港股，3)(新三股，4)(新四股,5)(中小板,6)', comment='上市版块的id----360企业画像（A股,1）(创业股，2)(港股，3)(新三股，4)(新四股,5)(中小板,6)') # 上市版块的id----360企业画像（A股,1）(创业股，2)(港股，3)(新三股，4)(新四股,5)(中小板,6)
foreign_investment = db.Column(db.String(32), doc='是否外商投资', comment='是否外商投资') # 是否外商投资
patent = db.Column(db.String(32), doc='是否为有专利企业', comment='是否为有专利企业') # 是否为有专利企业
num_patent = db.Column(db.Integer, doc='专利个数', comment='专利个数') # 专利个数
company_info = db.Column(db.Text, doc='公司简介', comment='公司简介') # 公司简介
dengl = db.Column(db.String(32), doc='瞪羚', comment='瞪羚') # 瞪羚
unicorn = db.Column(db.String(32), doc='独角兽企业', comment='独角兽企业') # 独角兽企业
isfive = db.Column(db.String(32), doc='是否中国500强', comment='是否中国500强') # 是否中国500强
product_all = db.Column(db.String(255), doc='公司拥有产品', comment='公司拥有产品') # 公司拥有产品
takingn = db.Column(db.Float, doc='营收', comment='营收') # 营收
hots = db.Column(db.Integer, doc='企业热度(权重值)', comment='企业热度(权重值)') # 企业热度(权重值)
c_name = db.Column(db.String(255), doc='行业类名', comment='行业类名') # 行业类名
c_type = db.Column(db.Integer, index=True, doc='行业类id', comment='行业类id') # 行业类id
f_name = db.Column(db.String(255), doc='父行业类名', comment='父行业类名') # 父行业类名
f_type = db.Column(db.Integer, index=True, doc='父行业类id', comment='父行业类id') # 父行业类id
# __table_args__ = (Index('index(zone,status)', 'resource_zone', 'resource_status'), {'comment': '压测资源表'}) # 添加索引和表注释
__table_args__ = ({'comment': '全国企业表'}) # 添加表注释
# 晋城企业表
class Company(db.Model):
__tablename__ = "company"
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='企业主键id', comment='企业主键id') # 企业
company_name = db.Column(db.String(255), doc='企业名', comment='企业名') # 企业名
status = db.Column(db.String(32), doc='经营状态', comment='经营状态') # 经营状态
legal = db.Column(db.String(32), doc='法定代表人', comment='法定代表人') # 法定代表人
capital = db.Column(db.String(255), doc='注册资本,22万美元', comment='注册资本,22万美元') # 注册资本,22万美元
capital_nums = db.Column(db.Float, doc='注册资本转换成人民币数值', comment='注册资本转换成人民币数值') # 注册资本转换成人民币数值
capital_id = db.Column(db.Integer, doc='注册资本大小类型，0-100,1,100-500,2,500-1000,3,1000-5000,4,5000-10000,5,10000+，6', comment='注册资本大小类型，0-100,1,100-500,2,500-1000,3,1000-5000,4,5000-10000,5,10000+，6') # 注册资本大小类型，0-100,1,100-500,2,500-1000,3,1000-5000,4,5000-10000,5,10000+，6
build_date = db.Column(db.DateTime, doc='注册时间', comment='注册时间') # 注册时间
yearid = db.Column(db.Integer, doc='成立时间年限id(1-3，1)(3-5，2)(5-8，3)（8-10，4）（10-15,5）（15以上，6）', comment='成立时间年限id(1-3，1)(3-5，2)(5-8，3)（8-10，4）（10-15,5）（15以上，6）') # 成立时间年限id(1-3，1)(3-5，2)(5-8，3)（8-10，4）（10-15,5）（15以上，6）
province = db.Column(db.String(32), doc='省', comment='省') # 省
city = db.Column(db.String(32), doc='市', comment='市') # 市
district = db.Column(db.String(32), doc='区', comment='区') # 区
lng = db.Column(db.String(100), doc='经度', comment='经度') # 经度
lat = db.Column(db.String(100), doc='纬度', comment='纬度') # 纬度
c_lng = db.Column(db.String(100), doc='市经度', comment='市经度') # 市经度
c_lat = db.Column(db.String(100), doc='市纬度', comment='市纬度') # 市纬度
d_lng = db.Column(db.String(100), doc='区经度', comment='区经度') # 区经度
d_lat = db.Column(db.String(100), doc='区纬度', comment='区纬度') # 区纬度
address = db.Column(db.String(255), doc='企业地址', comment='企业地址') # 企业地址
telephone = db.Column(db.Text, doc='电话', comment='电话') # 电话
telephone_more = db.Column(db.Text, doc='更多电话', comment='更多电话') # 更多电话
email = db.Column(db.Text, doc='邮箱', comment='邮箱') # 邮箱
social_code = db.Column(db.String(100), doc='统一社会信用代码', comment='统一社会信用代码') # 统一社会信用代码
tax_code = db.Column(db.String(100), doc='纳税人识别号', comment='纳税人识别号') # 纳税人识别号
register_code = db.Column(db.String(100), doc='注册号', comment='注册号') # 注册号
company_code = db.Column(db.String(100), doc='组织机构代码', comment='组织机构代码') # 组织机构代码
bao_num = db.Column(db.Integer, doc='参保人数', comment='参保人数') # 参保人数
entype = db.Column(db.String(100), doc='企业类型', comment='企业类型') # 企业类型
entypeid = db.Column(db.Integer, doc='公司类型id(个人独资企业-1)(股份有限公司-2)(有限责任公司-3)(合伙企业-4)(集体所有制-5)(全民所有制企业-6)(外商企业-7)', comment='公司类型id(个人独资企业-1)(股份有限公司-2)(有限责任公司-3)(合伙企业-4)(集体所有制-5)(全民所有制企业-6)(外商企业-7)') # 公司类型id(个人独资企业-1)(股份有限公司-2)(有限责任公司-3)(合伙企业-4)(集体所有制-5)
# (全民所有制企业-6)(外商企业-7)
company_industry = db.Column(db.String(100), doc='所属行业', comment='所属行业') # 所属行业
web_site = db.Column(db.String(255), doc='企业网址', comment='企业网址') # 企业网址
business_scope = db.Column(db.Text, doc='企业经营范围', comment='企业经营范围') # 企业经营范围
money_type = db.Column(db.String(100), doc='注册币种', comment='注册币种') # 注册币种
money_type_id = db.Column(db.Integer, doc='注册币种类型id', comment='注册币种类型id') # 注册币种类型id
high_new = db.Column(db.String(32), doc='是否高新技术企业', comment='是否高新技术企业') # 是否高新技术企业
parti_year = db.Column(db.Integer, doc='高新企业注册年份', comment='高新企业注册年份') # 高新企业注册年份
tbe = db.Column(db.String(32), doc='是否科技型中小企业', comment='是否科技型中小企业') # 是否科技型中小企业
fianacing = db.Column(db.String(32), doc='是否为有融资企业', comment='是否为有融资企业') # 是否为有融资企业
fianacing_rounds = db.Column(db.String(32), doc='融资轮次', comment='融资轮次') # 融资轮次
roundid = db.Column(db.Integer, doc='融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）', comment='融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）') # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
financing_amount = db.Column(db.Float, doc='融资金额', comment='融资金额') # 融资金额
software_copyright = db.Column(db.String(32), doc='是否为有软件著作权', comment='是否为有软件著作权') # 是否为有软件著作权
num_software = db.Column(db.Integer, doc='软件著作权个数', comment='软件著作权个数') # 软件著作权个数
public_sector = db.Column(db.String(32), doc='上市板块', comment='上市板块') # 上市板块
quoted_company = db.Column(db.String(32), doc='是否上市企业', comment='是否上市企业') # 是否上市企业
public_id = db.Column(db.Integer, doc='上市版块的id----360企业画像（A股,1）(创业股，2)(港股，3)(新三股，4)(新四股,5)(中小板,6)', comment='上市版块的id----360企业画像（A股,1）(创业股，2)(港股，3)(新三股，4)(新四股,5)(中小板,6)') # 上市版块的id----360企业画像（A股,1）(创业股，2)(港股，3)(新三股，4)(新四股,5)(中小板,6)
foreign_investment = db.Column(db.String(32), doc='是否外商投资', comment='是否外商投资') # 是否外商投资
patent = db.Column(db.String(32), doc='是否为有专利企业', comment='是否为有专利企业') # 是否为有专利企业
num_patent = db.Column(db.Integer, doc='专利个数', comment='专利个数') # 专利个数
induzone = db.Column(db.String(255), doc='所在园区', comment='所在园区') # 所在园区
company_info = db.Column(db.Text, doc='公司简介', comment='公司简介') # 公司简介
sxmon = db.Column(db.String(32), doc='是否山西民营100强', comment='是否山西民营100强') # 是否山西民营100强（2019年）
zjtg = db.Column(db.String(32), doc='山西专精特工企业', comment='山西专精特工企业') # 山西专精特工企业
unicorn = db.Column(db.String(32), doc='独角兽企业', comment='独角兽企业') # 独角兽企业
dengl = db.Column(db.String(32), doc='瞪羚', comment='瞪羚') # 瞪羚
hncode = db.Column(db.String(32), doc='高企证书编号', comment='高企证书编号') # 高企证书编号
isfive = db.Column(db.String(32), doc='是否中国500强', comment='是否中国500强') # 是否中国500强
istyfive = db.Column(db.String(32), doc='是否2020中国500强', comment='是否2020中国500强') # 是否2020中国500强
quotedate = db.Column(db.DateTime, doc='上市时间', comment='上市时间') # 上市时间
sxonhun = db.Column(db.String(32), doc='是否山西100强', comment='是否山西100强') # 是否山西100强
product_all = db.Column(db.String(255), doc='公司拥有产品', comment='公司拥有产品') # 公司拥有产品
scale = db.Column(db.String(32), doc='规模以上企业', comment='规模以上企业') # 规模以上企业
serve = db.Column(db.String(32), doc='限额以上服务业', comment='限额以上服务业') # 限额以上服务业
takingn = db.Column(db.Float, doc='营收 (万元)', comment='营收 (万元)') # 2019营收 (万元)
ouputn = db.Column(db.Float, doc='年产值', comment='年产值') # 2019年产值
profit = db.Column(db.Float, doc='公司利润（万元）', comment='公司利润（万元）') # 2019公司利润（万元）
c_name = db.Column(db.String(255), doc='行业类名', comment='行业类名') # 行业类名
c_type = db.Column(db.Integer, doc='行业类id', comment='行业类id') # 行业类id
f_name = db.Column(db.String(255), doc='父行业类名', comment='父行业类名') # 父行业类名
f_type = db.Column(db.Integer, doc='父行业类id', comment='父行业类id') # 父行业类id
hots = db.Column(db.Integer, doc='企业热度', comment='企业热度') # 企业热度
sort_num = db.Column(db.Integer, doc='权重值', comment='权重值') # 权重值
stream = db.Column(db.String(32), doc='行业上下游', comment='行业上下游') # 行业上下游
product = db.Column(db.String(255), doc='生产产品', comment='生产产品') # 生产产品
__table_args__ = ({'comment': '晋城企业表'}) # 添加表注释
# 产业导航目录
class Industry(db.Model):
__tablename_ = "industry"
__table_args__ = ({'comment': '产业导航目录表'}) # 添加表注释
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='产业主键id', comment='产业主键id')
name = db.Column(db.String(32), doc='导航名', comment='导航名') # 导航名
oname = db.Column(db.String(32), doc='导航真名', comment='导航真名') # 导航真名
nid = db.Column(db.Integer, doc='导航id(对应企业数据表中的f_type)', comment='导航id(对应企业数据表中的f_type)') # 导航id(导航在企业数据中的id)
fid = db.Column(db.Integer, doc='表中fid', comment='表中fid') # 表中fid
statu = db.Column(db.Integer, doc='启用状态1启用，2禁用', comment='启用状态1启用，2禁用') # 启用状态1启用，2禁用
info = db.Column(db.Text, doc='行业简介', comment='行业简介') # 行业简介
companys = db.Column(db.Integer, doc='行业下企业数', comment='行业下企业数') # 行业下企业数
entities = db.Column(db.Integer, doc='行业所包含细分行业实体数', comment='行业所包含细分行业实体数') # 行业所包含细分行业实体数
# 招商驾驶舱-区县经济指标表
class City(BaseModel, db.Model):
__tablename__ = "city"
__table_args__ = ({'comment': '招商驾驶舱-区县经济指标表'}) # 添加表注释
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='经济指标主键id', comment='经济指标主键id')
area = db.Column(db.String(255), doc='区县名称', comment='区县名称') # 区县名称
size = db.Column(db.Float, doc='区县面积', comment='区县面积') # 区县面积
year = db.Column(db.Integer, doc='年份', comment='年份') # 年份
people = db.Column(db.Integer, doc='人口', comment='人口') # 人口
GDP = db.Column(db.Float, doc='GDP(万元)', comment='GDP(万元)') # GDP(万元)
investment = db.Column(db.Float, doc='固定投资资产', comment='固定投资资产') # 固定投资资产
retail = db.Column(db.Float, doc='社会消费品零售总额', comment='社会消费品零售总额') # 社会消费品零售总额
public = db.Column(db.Float, doc='一般公共预算支出', comment='一般公共预算支出') # 一般公共预算支出
public_in = db.Column(db.Float, doc='一般公共预算收入', comment='一般公共预算收入') # 一般公共预算收入
addscale = db.Column(db.Float, doc='规上工业增加值', comment='规上工业增加值') # 规上工业增加值
people_out = db.Column(db.Float, doc='居然人均可支配收入', comment='居然人均可支配收入') # 居然人均可支配收入
people_per = db.Column(db.Float, doc='居民消费价格指数', comment='居民消费价格指数') # 居民消费价格指数
in_out = db.Column(db.Float, doc='进出口总额', comment='进出口总额') # 进出口总额
info = db.Column(db.Text, doc='基本信息', comment='基本信息') # 基本信息
question = db.Column(db.Text, doc='标注', comment='标注') # 标注
# 招商驾驶舱-各区县视频
class Video(db.Model):
__tablename__ = "video"
__table_args__ = ({'comment': '招商驾驶舱-各区县视频表'}) # 添加表注释
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='视频主键id', comment='视频主键id')
district = db.Column(db.String(32), nullable=False, doc='区县名称', comment='区县名称')
video_id = db.Column(db.String(35), doc='视频', comment='视频')
# 招商驾驶舱-项目数量/金额产业分布图
class NewProject(BaseModel, db.Model):
__tablename__ = "newproject"
__table_args__ = ({'comment': '招商驾驶舱-项目数量/金额产业分布表'}) # 添加表注释
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='主键id', comment='主键id') # id
type = db.Column(db.String(255), doc='产业类型', comment='产业类型') # 产业类型
number = db.Column(db.Integer, doc='项目个数', comment='项目个数') # 项目个数
money = db.Column(db.Float, doc='价格', comment='价格') # 价格
district = db.Column(db.String(255), doc='区县名称', comment='区县名称') #
# 招商驾驶舱-招商引资作战图
class Examine(BaseModel, db.Model):
__tablename__ = "examine"
__table_args__ = ({'comment': '招商驾驶舱-招商引资作战图表'}) # 添加表注释
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='主键id', comment='主键id') # id
district = db.Column(db.String(255), doc='县区', comment='县区') # 县区
year = db.Column(db.Integer, doc='年', comment='年') # 年
month = db.Column(db.Integer, doc='月', comment='月') # 月
project_num = db.Column(db.Integer, doc='项目个数', comment='项目个数') # 项目个数
sign_aim = db.Column(db.Integer, doc='签约目标', comment='签约目标') # 签约目标
sign_finnish = db.Column(db.Float, doc='签约的完成', comment='签约的完成') # 签约的完成
sign_grade = db.Column(db.Float, doc='签约的得分，签约项目投资额完成率', comment='签约的得分，签约项目投资额完成率') # 签约的得分，签约项目投资额完成率
start_finish = db.Column(db.Float, doc='开工实际投资', comment='开工实际投资') # 开工实际投资
start_grade = db.Column(db.Float, doc='开工项目完成得分，开工项目计划投资额完成率', comment='开工项目完成得分，开工项目计划投资额完成率') # 开工项目完成得分，开工项目计划投资额完成率
invest_finish = db.Column(db.Float, doc='固投已完成', comment='固投已完成') # 固投已完成
invest_grade = db.Column(db.Float, doc='固投得分，开工项目到位资金额', comment='固投得分，开工项目到位资金额') # 固投得分，开工项目到位资金额
start_num = db.Column(db.Integer, doc='项目的开工个数', comment='项目的开工个数') # 项目的开工个数
start_num_grade = db.Column(db.Float, doc='签约开工率得分', comment='签约开工率得分') # 签约开工率得分
start_aim = db.Column(db.Float, doc='开工计划金额', comment='开工计划金额') # 开工计划金额
invest_aim = db.Column(db.Float, doc='固投目标金额', comment='固投目标金额') # 固投目标金额
invest_aim_f = db.Column(db.Float, doc='非固投目标金额', comment='非固投目标金额') # 非固投目标金额
invest_finish_f = db.Column(db.Integer, doc='非固投已完成', comment='非固投已完成') # 非固投已完成
invest_grade_f = db.Column(db.Float, doc='非固投得分', comment='非固投得分') # 非固投得分
grade = db.Column(db.Integer, doc='综合排名', comment='综合排名') # 综合排名
# 招商驾驶舱-重点招商项目表
class Project(BaseModel, db.Model):
__tablename__ = "project"
__table_args__ = ({'comment': '招商驾驶舱-重点招商项目表'}) # 添加表注释
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='工程id', comment='工程id') # 工程id
name = db.Column(db.String(255), doc='工程名', comment='工程名') # 一.工程名
district = db.Column(db.String(255), doc='区县名称', comment='区县名称') # 二.县区
type = db.Column(db.String(255), doc='工程类型', comment='工程类型') # 三.(1)工程类型
money = db.Column(db.String(255), doc='项目投资金额', comment='项目投资金额') # 三.(2)项目投资金额
background = db.Column(db.Text, doc='项目背景', comment='项目背景') # 三.(3)项目背景
content = db.Column(db.Text, doc='项目的具体内容', comment='项目的具体内容') # 三.(4)项目的具体内容
way = db.Column(db.Text, doc='拟引资方式及内容', comment='拟引资方式及内容') # 四.拟引资方式及内容
company = db.Column(db.String(255), doc='招商单位', comment='招商单位') # 五.(1)招商单位
contact = db.Column(db.String(255), doc='联系方式', comment='联系方式') # 五.(2)联系方式
email = db.Column(db.String(255), doc='电子邮箱', comment='电子邮箱') # 五.(3)电子邮箱
# 招商驾驶舱-产业政策
class InduPolicy(db.Model):
__tablename_ = "indupolicy"
__table_args__ = ({'comment': '招商驾驶舱-产业政策'}) # 添加表注释
id = db.Column(db.Integer, primary_key=True, autoincrement=True, doc='政策主键id', comment='政策主键id')
name = db.Column(db.String(255), doc='政策名', comment='政策名') # 政策名
post_num = db.Column(db.String(255), doc='发文字号', comment='发文字号') # 发文字号
industry = db.Column(db.String(32), doc='行业名称', comment='行业名称') # 行业名称
pubdate = db.Column(db.DateTime, doc='发布时间', comment='发布时间') # 发布时间
year = db.Column(db.Integer, doc='发布年份', comment='发布年份') # 发布年份
url = db.Column(db.String(255), doc='外链接', comment='外链接') # 外链接
file = db.Column(db.String(255), doc='本地文件位置', comment='本地文件位置') # 本地文件位置
category = db.Column(db.String(32), doc='政策类型', comment='政策类型') # 政策类型
org = db.Column(db.String(255), doc='政策发布机构', comment='政策发布机构') # 政策发布机构
district = db.Column(db.String(32), doc='政策发布地区', comment='政策发布地区') # 政策发布地区
body = db.Column(db.Text, doc='正文', comment='正文') # 正文（2021-4-13改为发布机构筛选条件）
navigator = db.Column(db.String(255), doc='导航一', comment='导航一') # 导航一
navigat = db.Column(db.String(255), doc='导航二', comment='导航二') # 导航二
level = db.Column(db.String(255), doc='级别', comment='级别') # 级别
sorts = db.Column(db.Integer, doc='机构排序', comment='机构排序') # 机构排序
sorts_level = db.Column(db.Integer, doc='发布机构排序', comment='发布机构排序') # 发布机构排序
# 项目列表
# class Item(db.Model):
# __tablename_ = "item"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 项目id
# build_date = db.Column(db.DateTime) # 成立时间
# company_name = db.Column(db.String(255)) # 项目企业
# admin = db.Column(db.String(255)) # 企业联系人
# mobile = db.Column(db.String(255)) # 企业联系人联系电话
# email = db.Column(db.String(255)) # 企业联系邮箱
#
# name = db.Column(db.String(255)) # 项目名称
# store = db.Column(db.DateTime) # 项目入库时间
# product = db.Column(db.String(255)) # 生产产品
# industry = db.Column(db.String(255)) # 所在行业
# indu_id = db.Column(db.Integer) # 所在行业id
# invest = db.Column(db.Float) # 投资额(亿元)
# # invest = db.Column(db.String(32)) # 投资额(万元)
# invest_id = db.Column(db.Integer) # 投资额id
#
# area = db.Column(db.String(255)) # 占地面积
# value = db.Column(db.Float) # 预计产值（万）
# tax = db.Column(db.Float) # 预计税收（万）
#
# unit = db.Column(db.String(255)) # 项目所在机构、单位、局
# section = db.Column(db.String(255)) # 项目所在部门
# link = db.Column(db.String(255)) # 对接人（手动填充，非创建者也可以）
# link_mobile = db.Column(db.String(255)) # 对接人的联系方式
# user_id = db.Column(db.Integer) # 项目创建人id
#
# level = db.Column(db.String(255)) # 项目的级别
# level_id = db.Column(db.Integer) # 项目级别id
# stage = db.Column(db.String(255)) # 项目的进度
# stage_id = db.Column(db.Integer) # 项目进度id
#
# status = db.Column(db.String(255)) # 项目上报状态
# belong = db.Column(db.Integer) # 是否为太原市投促局项目 1是，2否
# share = db.Column(db.String(255)) # 共享人
# unit_up = db.Column(db.String(255)) # 被上报局
#
# main_introduce = db.Column(db.Text) # 项目主体介绍
# invest_introduce = db.Column(db.Text) # 投资项目介绍
# build_introduce = db.Column(db.Text) # 项目建设内容
# encomy = db.Column(db.Text) # 项目的经济效益
# policy = db.Column(db.Text) # 项目政策需求
# question = db.Column(db.Text) # 项目进展及存在的问题
#
#
# # 项目阶段表
# class Trends(BaseModel, db.Model):
# __tablename__ = "trends"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# stage = db.Column(db.String(255)) # 项目的阶段
# unit = db.Column(db.String(255)) # 主导机构
# user = db.Column(db.String(255)) # 更新人
# item_id = db.Column(db.Integer, db.ForeignKey("item.id")) # 项目ID
# item = db.relationship('Item', backref=db.backref('trends')) # 外键联系
#
#
# # 招商资源管理项目文件
# class File(BaseModel, db.Model):
# __tablename__ = "file"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name = db.Column(db.String(255)) # 上传文件名
# file_size = db.Column(db.String(255)) # 文件大小
# uploader = db.Column(db.String(255)) # 上传人
# url = db.Column(db.String(255)) # url
# item_id = db.Column(db.Integer, db.ForeignKey("item.id")) # 项目ID
# item = db.relationship('Item', backref=db.backref('file')) # 外键联系
#
#
# # 政府机构之间的上下级统筹
# followers = db.Table('followers',
# db.Column('follower_id', db.Integer, db.ForeignKey('government.id'), primary_key=True),
# db.Column('followed_id', db.Integer, db.ForeignKey('government.id'), primary_key=True)
# )
#
#
# # 政府机构表（自关联多对多）
# class Government(db.Model):
# __tablename__ = "government"
# # 基本信息
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# pnums = db.Column(db.Integer) # 人数
# charge = db.Column(db.String(255)) # 机构负责人
# charge_phone = db.Column(db.String(255)) # 负责人电话
# function = db.Column(db.Text) # 部门职能
# name = db.Column(db.String(255), nullable=False, index=True) # 政府机构单位名称
# # followed 我的下级，管制谁，followers 我的上级，谁管制我
# followed = db.relationship('Government', secondary=followers, primaryjoin=(followers.c.follower_id == id),
# secondaryjoin=(followers.c.followed_id == id),
# backref=db.backref('followers', lazy='dynamic'), lazy='dynamic')
#
#
# # 政府部门（政府-部门 一对多）
# class Section(db.Model):
# __tablename__ = "section"
# # 基本信息
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# pnums = db.Column(db.Integer) # 人数
# charge = db.Column(db.String(255)) # 部门负责人
# charge_phone = db.Column(db.String(255)) # 负责人电话
# function = db.Column(db.Text) # 部门职能
# name = db.Column(db.String(255), nullable=False) # 政府机构部门名称
# # gid = db.Column(db.Integer) # 政府id
# goverment_id = db.Column(db.Integer, db.ForeignKey("government.id"))
# goverment = db.relationship('Government', backref=db.backref('sections')) # 政府1-N部门
#
#
# # 政府组（政府1-N部门1-N组）
# class Group(db.Model):
# __tablename__ = "group"
# # 基本信息
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# pnums = db.Column(db.Integer) # 人数
# charge = db.Column(db.String(255)) # 组负责人
# charge_phone = db.Column(db.String(255)) # 负责人电话
# function = db.Column(db.Text) # 部门职能
# name = db.Column(db.String(255), nullable=False) # 政府机构部门下组的名称
# # sid = db.Column(db.Integer) # 部门id
# section_id = db.Column(db.Integer, db.ForeignKey("section.id"))
# section = db.relationship('Section', backref=db.backref('groups')) # 部门1-N组
#
#
# # 用户关注行业，多-多
# class UserIndustry(BaseModel, db.Model):
# __tablename__ = "user_industry"
#
# user_id = db.Column(db.Integer, db.ForeignKey("user.id"), primary_key=True)
# industry_id = db.Column(db.Integer, db.ForeignKey("industry.id"), primary_key=True)
#
#
# # #用户关注公司，多-多
# class UserCompany(BaseModel, db.Model):
# __tablename__ = "user_company"
#
# user_id = db.Column(db.Integer, db.ForeignKey("user.id"), primary_key=True)
# company_id = db.Column(db.Integer, db.ForeignKey("company.id"), primary_key=True)
#
#
# # #用户关注公司，多-多
# class UserEnterprise(BaseModel, db.Model):
# __tablename__ = "user_enterprise"
#
# user_id = db.Column(db.Integer, db.ForeignKey("user.id"), primary_key=True)
# enterprise_id = db.Column(db.Integer, db.ForeignKey("enterprise.id"), primary_key=True)
#
#
# # 用户
# class User(BaseModel, db.Model):
# __tablename__ = "user"
#
# # 基本信息
# id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 用户编号
# name = db.Column(db.String(32), unique=True) # 用户名
# password_hash = db.Column(db.String(128)) # 加密的密码
# real_name = db.Column(db.String(32)) # 姓名
# age = db.Column(db.Integer) # 年龄
# sex = db.Column(db.Integer) # 性别，男1女2
# mobile = db.Column(db.String(11), unique=True) # 手机号
# email = db.Column(db.String(20)) # 邮箱
# # 个人中心的信息
# function = db.Column(db.Text) # 工作职能 ---个人中心
# flag = db.Column(db.Integer) # 普通1，政府2
# status = db.Column(db.Integer) # 通过1，在审2,驳回3
# # bused = db.Column(db.Integer) # 账户有无组织
# # 政府信息
# position = db.Column(db.String(128)) # 现任职务（职务）
# unit = db.Column(db.String(128)) # 现任工作机构、单位（政府机构，局）
# section = db.Column(db.String(128)) # 所在部门（部门）
# group = db.Column(db.String(128)) # 所在组
# level = db.Column(db.String(128)) # 职级（职级） 跟role_id对应
# leader = db.Column(db.String(32)) # 领导（直属领导）
#
# # 三方登陆唯一标识
# # 微信
# vxopenid = db.Column(db.String(128), unique=True) # 微信openid
# vxunionid = db.Column(db.String(128), unique=True) # 微信unionid
# # 角色(职级配置)
# role_id = db.Column(db.Integer, db.ForeignKey("role.id"))
# role = db.relationship("Role", backref=db.backref("users"))
#
# # # 钉钉
# # ddopenid = db.Column(db.String(128)) # 钉钉openid
# # ddunionid = db.Column(db.String(128)) # 钉钉unionid
# # dddingid = db.Column(db.String(128)) # 钉钉dingid
#
# # 用户关注行业（图谱）
# industry = db.relationship("Industry", secondary="user_industry", backref=db.backref('bindustry'))
# # 用户关注太原企业
# company = db.relationship("Company", secondary="user_company", backref=db.backref("bcompany"))
# # 用户关注全国企业
# enterprise = db.relationship("Enterprise", secondary="user_enterprise", backref=db.backref("benterprise"))
#
# @property
# def password(self):
# # 设置为只写的方式
# # return self.password_hash
# raise AttributeError('这个属性只能设置，不能读取')
#
# @password.setter
# def password(self, value):
# self.password_hash = generate_password_hash(value)
#
# def check_password(self, password):
# '''检验密码的正确性，传入参数为用户登录时填写的密码'''
# return check_password_hash(self.password_hash, password)
#
# # 生成token
# @staticmethod
# def create_token(user_id):
# """
# 生成token,生成方式（ 内部配置的私钥+有效期+用户的id ）
# :param user_id: 用户id
# :return:
# """
# # 第一个参数是内部的私钥,写在配置里,第二个参数是有效期（秒）
# s = Serializer(Config.SECRET_KEY, expires_in=Config.TOKEN_EXPIRATION)
# # 接收用户id转换与编码
# token = s.dumps({"id": user_id}).decode('ascii')
# print(token)
# return token
#
#
# # 角色（职位，职级）
# class Role(BaseModel, db.Model):
# __tablename__ = "role"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 企业
# role_name = db.Column(db.String(255), unique=True) # 角色名
# role = db.Column(db.String(10), unique=True) # 权限值 000000 0位位职级123，后面为权限01
# info = db.Column(db.String(255)) # 权限说明
#
#
#
#
#
# # 招商驾驶舱企业数据
# class Atcompany(db.Model):
# __tablename__ = "atcompany"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 企业
# company_name = db.Column(db.String(255)) # 企业名
# status = db.Column(db.String(32)) # 经营状态
# legal = db.Column(db.String(32)) # 法定代表人
# capital = db.Column(db.String(255)) # 注册资本,22万美元
# capital_nums = db.Column(db.Float) # 注册资本转换成人民币数值
# capital_id = db.Column(db.Integer) # 修改为对应companyid
# build_date = db.Column(db.DateTime) # 注册时间
# yearid = db.Column(db.Integer) # 成立时间年限id(1-3，1)(3-5，2)(5-8，3)（8-10，4）（10-15,5）（15以上，6）
# province = db.Column(db.String(32)) # 省
# city = db.Column(db.String(32)) # 市
# district = db.Column(db.String(32)) # 区
# lng = db.Column(db.String(100)) # 经度
# lat = db.Column(db.String(100)) # 纬度
# c_lng = db.Column(db.String(100)) # 市经度
# c_lat = db.Column(db.String(100)) # 市纬度
# d_lng = db.Column(db.String(100)) # 区经度
# d_lat = db.Column(db.String(100)) # 区纬度
# address = db.Column(db.String(255)) # 企业地址
# telephone = db.Column(db.Text) # 电话
# telephone_more = db.Column(db.Text) # 更多电话
# email = db.Column(db.Text) # 邮箱
# social_code = db.Column(db.String(100)) # 统一社会信用代码
# tax_code = db.Column(db.String(100)) # 纳税人识别号
# register_code = db.Column(db.String(100)) # 注册号
# company_code = db.Column(db.String(100)) # 组织机构代码
# bao_num = db.Column(db.Integer) # 参保人数
# entype = db.Column(db.String(100)) # 企业类型
# entypeid = db.Column(db.Integer) # 公司类型id(个人独资企业-1)(股份有限公司-2)(有限责任公司-3)(合伙企业-4)(集体所有制-5)
# # (全民所有制企业-6)(外商企业-7)
#
# company_industry = db.Column(db.String(100)) # 所属行业
# web_site = db.Column(db.String(255)) # 企业网址
# business_scope = db.Column(db.Text) # 企业经营范围
# money_type = db.Column(db.String(100)) # 注册币种
# money_type_id = db.Column(db.Integer) # 注册币种类型id
#
# high_new = db.Column(db.String(32)) # 是否高新技术企业
# parti_year = db.Column(db.Integer) # 高新企业注册年份
# tbe = db.Column(db.String(32)) # 是否科技型中小企业
# fianacing = db.Column(db.String(32)) # 是否为有融资企业
# fianacing_rounds = db.Column(db.String(32)) # 融资轮次
# roundid = db.Column(db.Integer) # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
# financing_amount = db.Column(db.Float) # 融资金额
# software_copyright = db.Column(db.String(32)) # 是否为有软件著作权
# num_software = db.Column(db.Integer) # 软件著作权个数
# public_sector = db.Column(db.String(32)) # 上市板块
# quoted_company = db.Column(db.String(32)) # 是否上市企业
# public_id = db.Column(db.Integer) # 上市版块的id----360企业画像（A股,1）(创业股，2)(港股，3)(新三股，4)(新四股,5)(中小板,6)
#
# foreign_investment = db.Column(db.String(32)) # 是否外商投资
# patent = db.Column(db.String(32)) # 是否为有专利企业
# num_patent = db.Column(db.Integer) # 专利个数
# induzone = db.Column(db.String(255)) # 所在园区
# company_info = db.Column(db.Text) # 公司简介
#
# sxmon = db.Column(db.String(32)) # 是否山西民营100强（2019年）
# zjtg = db.Column(db.String(32)) # 山西专精特工企业
# unicorn = db.Column(db.String(32)) # 独角兽企业
# dengl = db.Column(db.String(32)) # 瞪羚
# hncode = db.Column(db.String(32)) # 高企证书编号
# isfive = db.Column(db.String(32)) # 是否中国500强
# istyfive = db.Column(db.String(32)) # 是否2020中国500强
# quotedate = db.Column(db.DateTime) # 上市时间
# sxonhun = db.Column(db.String(32)) # 是否山西100强
#
# product_all = db.Column(db.String(255)) # 公司拥有产品
# scale = db.Column(db.String(32)) # 规模以上企业
# serve = db.Column(db.String(32)) # 限额以上服务业
#
# takingn = db.Column(db.Float) # 2019营收 (万元)
# ouputn = db.Column(db.Float) # 2019年产值
# profit = db.Column(db.Float) # 2019公司利润（万元）
# c_name = db.Column(db.String(255)) # 行业类名
# c_type = db.Column(db.Integer) # 行业类id
# f_name = db.Column(db.String(255)) # 父行业类名
# f_type = db.Column(db.Integer) # 父行业类id
# hots = db.Column(db.Integer) # 企业热度
# sort_num = db.Column(db.Integer) # 权重值
# stream = db.Column(db.String(32)) # 行业上下游
# product = db.Column(db.String(255)) # 生产产品
#
#
#
#
#
# # 高等院校(985,211,本科，高职专高)
# class College(db.Model):
# __tablename_ = "college"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 省市区层级分类
#
# category = db.Column(db.String(255)) # 学校类型 211工程院校1,普通本科2,高职专高3
# cateid = db.Column(db.Integer) # 学校类型 211工程院校1,普通本科2,高职专高3
# name = db.Column(db.String(255)) # 高等院校高职专科等机构名称
# ccode = db.Column(db.String(255)) # 院校代码
# buildate = db.Column(db.String(255)) # 创建时间
# nature = db.Column(db.String(255)) # 办学性质
# clas = db.Column(db.String(255)) # 学校类别
# feature = db.Column(db.String(255)) # 学校特色
# charge = db.Column(db.String(255)) # 主管部门
# major = db.Column(db.String(255)) # 专业设置
# faculty = db.Column(db.String(255)) # 院系设置
# introduct = db.Column(db.Text) # 院校简介
# address = db.Column(db.String(255)) # 所在地址
# lng = db.Column(db.String(255)) # 经度
# lat = db.Column(db.String(255)) # 纬度
#
# navigator = db.Column(db.String(255)) # 导航一
# navigat = db.Column(db.String(255)) # 导航二
# # navigatorid = db.Column(db.String(32)) # 导航一id
# # navigatid = db.Column(db.String(32)) # 导航二id
#
# research = db.Column(db.String(255)) # 研究方向
# admin = db.Column(db.String(255)) # 所在行政区
# developarea = db.Column(db.String(255)) # 所在开发区
#
#
# # 科研机构
# class Scientific(db.Model):
# __tablename_ = "scientific"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# # oname = db.Column(db.String(64)) # 机构原名
# name = db.Column(db.String(255)) # 机构现名
# introduct = db.Column(db.Text) # 机构简介
# buildate = db.Column(db.DateTime) # 创建时间
# telephone = db.Column(db.String(255)) # 电话
# fax = db.Column(db.String(255)) # 传真
# postcode = db.Column(db.String(255)) # 邮编
# address = db.Column(db.String(255)) # 所在地址
# lng = db.Column(db.String(255)) # 经度
# lat = db.Column(db.String(255)) # 纬度
#
# research = db.Column(db.String(255)) # 研究方向
# admin = db.Column(db.String(255)) # 所在行政区
# developarea = db.Column(db.String(255)) # 所在开发区
#
# navigator = db.Column(db.String(255)) # 导航一
# navigat = db.Column(db.String(255)) # 导航二
# # navigatorid = db.Column(db.String(32)) # 导航一id
# # navigatid = db.Column(db.String(32)) # 导航二id
#
#
# # 创新平台（实验室等）
# class Lab(db.Model):
# __tablename_ = "lab"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
#
# cate = db.Column(db.String(255)) # 创新平台分类
# cateid = db.Column(db.Integer) # 创新平台分类id
# # 工程技术中心1,国际科技合作基地2,企业技术中心3,双创基地4,院士工作站5,质量检测与测量中心6,重点实验室7
#
# name = db.Column(db.String(255)) # 机构现名
# introduct = db.Column(db.Text) # 机构简介
# address = db.Column(db.String(255)) # 所在地址
# lng = db.Column(db.String(255)) # 经度
# lat = db.Column(db.String(255)) # 纬度
# city = db.Column(db.String(255)) # 城市
#
# navigator = db.Column(db.String(255)) # 导航一
# navigat = db.Column(db.String(255)) # 导航二
#
# research = db.Column(db.String(255)) # 研究方向
# admin = db.Column(db.String(255)) # 所在行政区
# developarea = db.Column(db.String(255)) # 所在开发区
#
#
# # 公共服务平台
# class Platform(db.Model):
# __tablename_ = "platform"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
#
# cate = db.Column(db.String(64)) # 产业服务平台分类 产业联盟1,公共服务平台2,行业协会3
# cateid = db.Column(db.Integer) # 产业服务平台分类id 产业联盟1,公共服务平台2,行业协会3
# name = db.Column(db.String(64)) # 平台名称
# introduct = db.Column(db.Text) # 平台简介
# address = db.Column(db.String(64)) # 地址
# lng = db.Column(db.String(100)) # 经度
# lat = db.Column(db.String(100)) # 纬度
# city = db.Column(db.String(32)) # 城市
#
# navigator = db.Column(db.String(255)) # 导航一
# navigat = db.Column(db.String(255)) # 导航二
#
# research = db.Column(db.String(255)) # 研究方向
# admin = db.Column(db.String(255)) # 所在行政区
# developarea = db.Column(db.String(255)) # 所在开发区
#
#
# # 资源机构的位置信息+research（产品词扩展）
# class Orgs(db.Model):
# __tablename_ = "orgs"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name = db.Column(db.String(255)) # 机构名
# category = db.Column(db.String(255)) # 机构类型
# admin = db.Column(db.String(255)) # 所在行政区
# lng = db.Column(db.String(255)) # 经度
# lat = db.Column(db.String(255)) # 纬度
#
# research = db.Column(db.String(255)) # research
# navigator = db.Column(db.String(255)) # 导航一
# navigat = db.Column(db.String(255)) # 导航二
#
#
# # 太原园区信息
# class Induzone(db.Model):
# __tablename_ = "induzone"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name = db.Column(db.String(255)) # 园区姓名
# image = db.Column(db.String(255)) # 园区单图链接http://192.168.132.165:5000/static/images/garden.jpg
# introduct = db.Column(db.Text) # 园区简介
# subzone = db.Column(db.String(255)) # 上级园区
# mainzone = db.Column(db.Text) # 主要产业园区
# level = db.Column(db.String(32)) # 园区级别
# zpolicy = db.Column(db.Text) # 产业政策
# district = db.Column(db.String(255)) # 园区区县
# charge = db.Column(db.String(255)) # 园区负责人
# phone = db.Column(db.String(255)) # 园区联系电话
# area = db.Column(db.Float) # 占地面积(平方公里)
# address = db.Column(db.String(255)) # 园区地址
# lng = db.Column(db.String(255)) # 经度
# lat = db.Column(db.String(255)) # 纬度
# cluster = db.Column(db.String(255)) # 产业集群
# cate = db.Column(db.String(255)) # 园区类型
#
# # 园区信息
# acreage = db.Column(db.Float) # 规划面积（平方公里）
# actarea = db.Column(db.Float) # 建成面积（平方公里）
# tax = db.Column(db.Float) # 税收要求（万元/亩）
# out_power = db.Column(db.Float) # 产出强度（万元/亩）
# invest_power = db.Column(db.Float) # 投资强度（万元/亩）
# indu_need = db.Column(db.String(255)) # 行业要求
# gdp = db.Column(db.Float) # GDP(亿元)
# fiscal = db.Column(db.Float) # 财政收入（亿元）
#
# indu_land = db.Column(db.String(255)) # 工业土地均价（万元/亩）
# indu_sup = db.Column(db.String(255)) # 工业土地供应量
# comm_land = db.Column(db.String(255)) # 商办土地均价（万元/亩）
# comm_sup = db.Column(db.String(255)) # 商办土地供应量
# represent = db.Column(db.Text) # 代表企业
# # 投资成本
# resident_ele_one = db.Column(db.String(255)) # 居民用电（一档）（元/度）
# resident_ele_two = db.Column(db.String(255)) # 居民用电（二档）（元/度）
# resident_ele_thr = db.Column(db.String(255)) # 居民用电（三档）（元/度）
# comm_ele_one = db.Column(db.String(255)) # 商业用电（峰段）（元/度）
# comm_ele_two = db.Column(db.String(255)) # 商业用电（平段）（元/度）
# comm_ele_thr = db.Column(db.String(255)) # 商业用电（谷段）（元/度）
# indu_ele_one = db.Column(db.String(255)) # 工业用电（峰段）（元/度）
# indu_ele_two = db.Column(db.String(255)) # 工业用电（平段）（元/度）
# indu_ele_thr = db.Column(db.String(255)) # 工业用电（谷段）（元/度）
# resident_water_one = db.Column(db.String(255)) # 居民用水（一档）（元/吨）
# resident_water_two = db.Column(db.String(255)) # 居民用水（二档）（元/吨）
# resident_water_thr = db.Column(db.String(255)) # 居民用水（三档）（元/吨）
# comm_water = db.Column(db.String(255)) # 商业用水（元/吨）
# indu_water = db.Column(db.String(255)) # 工业用水（元/吨）
# special_water = db.Column(db.String(255)) # 特种用水（元/吨）
# resident_natgas_one = db.Column(db.String(255)) # 居民用气（一档）（元/m³）
# resident_natgas_two = db.Column(db.String(255)) # 居民用气（二档）（元/m³）
# resident_natgas_thr = db.Column(db.String(255)) # 居民用气（三档）（元/m³）
# sewage = db.Column(db.String(255)) # 污水处理（元/吨）
# wagelevel = db.Column(db.String(255)) # 最低工资标准（元/月）
# worker = db.Column(db.String(255)) # 普通员工（元/月）
# middlemag = db.Column(db.String(255)) # 中级管理人员（元/月）
# highmag = db.Column(db.String(255)) # 高层管理人员（元/月）
# # 环境配套
# dis_freight = db.Column(db.Text) # 距离货运站距离
# dis_rail = db.Column(db.Text) # 距离高铁站
# dis_port = db.Column(db.Text) # 距离港口距离
# dis_air = db.Column(db.Text) # 距离机场距离
# road_trans = db.Column(db.Text) # 公路运输
# rail_trans = db.Column(db.Text) # 铁路运输
# live_facility = db.Column(db.Text) # 园区生活配套
# market = db.Column(db.Text) # 百货商场
# hotel_bus = db.Column(db.Text) # 酒店商务
# medical = db.Column(db.Text) # 医疗机构
# education = db.Column(db.Text) # 学校教育
#
# induenterprise = db.Column(db.Text) # 规模以上企业
# innovate = db.Column(db.Text) # 科研机构
# base = db.Column(db.Text) # 双创基地
# carrier = db.Column(db.Text) # 产业载体
#
# navigator = db.Column(db.String(255)) # 导航一
# navigat = db.Column(db.String(255)) # 导航二
# region = db.Column(db.String(255)) # 精确行政区
#
# # 用于园区
# gdp_point = db.Column(db.Float) # GDP的评分
# company_industry_point = db.Column(db.Float) # 园区控制大小
# warter_point = db.Column(db.Float) # 水费的评分
# electricity_point = db.Column(db.Float) # 电费的评分（）
# school_point = db.Column(db.Float) # 高校院所的评分
# mall_point = db.Column(db.Float) # 购物中心的评分
# hotel_point = db.Column(db.Float) # 酒店餐饮的评分
# policy_point = db.Column(db.Float) # 政策数的评分
#
# development_zone = db.Column(db.String(255)) # 所在开发区
#
#
# # 选址评分部分--企业聚合度
# class CompanyIndustryPoint(db.Model):
# __tablename_ = "company_industry_point"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# district = db.Column(db.String(32)) # 区县园区名
# point = db.Column(db.Float) # 分数
# f_type = db.Column(db.Integer) # 类型，对应产业导航nid
#
#
# # # 园区政策
# # class Zonepolicy(db.Model):
# # __tablename_ = "zonepolicy"
# #
# # id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# # name = db.Column(db.String(32)) # 园区政策名
# # pubdate = db.Column(db.DateTime) # 发布时间
# # org = db.Column(db.String(32)) # 政策发布机构
# # url = db.Column(db.String(255)) # 外链接
# # file = db.Column(db.String(255)) # 本地文件位置
# # induzone_id = db.Column(db.Integer, db.ForeignKey("induzone.id"))
# # zone = db.relationship('Induzone', backref=db.backref('policys')) # 园区政策
#
#
# # 产业政策（wf）
#
#
#
#
#
#
# # 企业属性导航ty（企业类型，资质，上市状态，融资轮次）
# class Propertyty(db.Model):
# __tablename_ = "propertyty"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name = db.Column(db.String(32)) # 字段名
# nid = db.Column(db.Integer) # 字段id
# sid = db.Column(db.Integer) # 字段类型id 1企业类型，2企业资质，3上市状态，4融资轮次
# statu = db.Column(db.Integer) # 状态 1启动，2禁用
#
#
# # 企业属性导航全部（企业类型，资质，上市状态，融资轮次）
# class Property(db.Model):
# __tablename_ = "property"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name = db.Column(db.String(32)) # 字段名
# nid = db.Column(db.Integer) # 字段id
# sid = db.Column(db.Integer) # 字段类型id 1企业类型，2企业资质，3上市状态，4融资轮次
# statu = db.Column(db.Integer) # 状态 1启动，2禁用
#
#
# # 招商资源管理字典（行业选择，项目阶段）
# class Attract(db.Model):
# __tablename_ = "attract"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name = db.Column(db.String(32)) # 字段名
# nid = db.Column(db.Integer) # 字段id（在项目数据中的id）
# sid = db.Column(db.Integer) # 字段类型id 1行业选择，2项目进度 3项目级别
# statu = db.Column(db.Integer) # 状态 1启动，2禁用
#
#
# # 园区信息管理字典（行业选择，项目阶段）
# class Zone(db.Model):
# __tablename_ = "zone"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name = db.Column(db.String(32)) # 字段名
# nid = db.Column(db.Integer) # 字段id（在项目中的id）
# sid = db.Column(db.Integer) # 字段类型id 1园区类别，2园区级别
# statu = db.Column(db.Integer) # 状态 1启动，2禁用
#
#
# # 雷达评估页行业在不同地区的测评分数
# class EvaluationData(db.Model):
# __tablename_ = "evaluationdata"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# c_type = db.Column(db.Integer) # 行业id
#
# province = db.Column(db.String(32)) # 省份
# city = db.Column(db.String(32)) # 城市
# district = db.Column(db.String(32)) # 区域
#
# development = db.Column(db.Integer) # 发育度
# contribute = db.Column(db.Integer) # 贡献度
# innovate = db.Column(db.Integer) # 创新度
# growup = db.Column(db.Integer) # 成长性
# capital = db.Column(db.Integer) # 资本力
# general = db.Column(db.Integer) # 综合分
#
#
# # 雷达评估页行业在不同地区的测评分数
# class EvaluationNodeData(db.Model):
# __tablename_ = "evaluationnodedata"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# c_type = db.Column(db.Integer, index=True) # 行业id
#
# province = db.Column(db.String(32), index=True) # 省份
# city = db.Column(db.String(32), index=True) # 城市
# district = db.Column(db.String(32), index=True) # 区域
#
# product = db.Column(db.String(32), index=True) # 产品名
# score = db.Column(db.Integer) # 综合分
#
#
# # 查找历史表
# class SearchList(BaseModel, db.Model):
# __tablename__ = "search_list"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# history = db.Column(db.String(128)) # 用户搜索历史
# user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
# section = db.relationship('User', backref=db.backref('searchlist')) # 用户-搜索
#
#
#
#
#
#
#
#
#
#
#
#
#
#
# # # 产品描述简介
# # class ProductInfo(BaseModel, db.Model):
# # __tablename__ = "product_info"
# #
# # id = db.Column(db.Integer, primary_key=True, autoincrement=True) # id
# # name = db.Column(db.String(32)) # 产品名
# # info = db.Column(db.Text) # 产品描述
#
#
# # 后台管理用户
# class Bstage(BaseModel, db.Model):
# __tablename__ = "bstage"
#
# # 基本信息
# id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 用户编号
# name = db.Column(db.String(32), unique=True) # 用户名
# password_hash = db.Column(db.String(128)) # 加密的密码
#
# # 角色(职级配置)
# role = db.Column(db.Integer) # 1超级管理员，2 系统运维员
#
# @property
# def password(self):
# # 设置为只写的方式
# # return self.password_hash
# raise AttributeError('这个属性只能设置，不能读取')
#
# @password.setter
# def password(self, value):
# self.password_hash = generate_password_hash(value)
#
# def check_password(self, password):
# '''检验密码的正确性，传入参数为用户登录时填写的密码'''
# return check_password_hash(self.password_hash, password)
#
#
# # 区域要素管理（园区）
# class Garden(db.Model):
# __tablename__ = "garden"
#
# # 基本信息
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
#
# unit = db.Column(db.String(255)) # 园区所属机构
# section = db.Column(db.String(255)) # 园区所属部门
# user = db.Column(db.Integer) # 园区创建人id
# uperson = db.Column(db.String(255)) # 园区上报人
# up_unit = db.Column(db.String(255)) # 园区上报机构
# status = db.Column(db.Enum("审核通过", "审核驳回", "正在审核", "未上报"), default="未上报", index=True) # 园区上报状态
#
# name = db.Column(db.String(255)) # 园区姓名
# level = db.Column(db.String(255)) # 园区级别
# charge = db.Column(db.String(255)) # 园区负责人
# phone = db.Column(db.String(255)) # 园区联系电话
# cate = db.Column(db.String(255)) # 园区类型
# address = db.Column(db.String(255)) # 园区地址
# cluster = db.Column(db.String(255)) # 产业集群（多选）
#
# # 土地信息
# land_code = db.Column(db.String(255)) # 土地位置/编号
# land_property = db.Column(db.String(255)) # 土地性质
# land_range = db.Column(db.String(255)) # 土地范围
# land_size = db.Column(db.String(255)) # 土地面积/平方公里
# indu_appeal = db.Column(db.String(255)) # 产业诉求
# # 楼宇信息
# build_name = db.Column(db.String(255)) # 楼宇名称
# build_add = db.Column(db.String(255)) # 楼宇地址
# build_size = db.Column(db.String(255)) # 楼宇面积/平方公里
# build_appeal = db.Column(db.String(255)) # 楼宇诉求
# # 厂房信息
# plant_add = db.Column(db.String(255)) # 厂房位置
# plant_size = db.Column(db.String(255)) # 厂房面积
# plant_condition = db.Column(db.String(255)) # 厂房条件
#
# # 园区信息
# area = db.Column(db.String(64)) # 占地面积(平方公里)
# acreage = db.Column(db.String(32)) # 规划面积（平方公里）
# actarea = db.Column(db.String(32)) # 建成面积（平方公里）
# tax = db.Column(db.String(32)) # 税收要求（万元/亩）
# out_power = db.Column(db.String(32)) # 产出强度（万元/亩）
# invest_power = db.Column(db.String(32)) # 投资强度（万元/亩）
# indu_need = db.Column(db.String(255)) # 行业要求
# gdp = db.Column(db.String(32)) # GDP(亿元)
# fiscal = db.Column(db.String(32)) # 财政收入（亿元）
# indu_land = db.Column(db.String(32)) # 工业土地均价（万元/亩）
# indu_sup = db.Column(db.String(32)) # 工业土地供应量
# comm_land = db.Column(db.String(32)) # 商办土地均价（万元/亩）
# comm_sup = db.Column(db.String(32)) # 商办土地供应量
# represent = db.Column(db.Text) # 代表企业
#
# # 投资成本
# resident_ele_one = db.Column(db.String(32)) # 居民用电（一档）（元/度）
# resident_ele_two = db.Column(db.String(32)) # 居民用电（二档）（元/度）
# resident_ele_thr = db.Column(db.String(32)) # 居民用电（三档）（元/度）
# comm_ele_one = db.Column(db.String(32)) # 商业用电（峰段）（元/度）
# comm_ele_two = db.Column(db.String(32)) # 商业用电（平段）（元/度）
# comm_ele_thr = db.Column(db.String(32)) # 商业用电（谷段）（元/度）
# indu_ele_one = db.Column(db.String(32)) # 工业用电（峰段）（元/度）
# indu_ele_two = db.Column(db.String(32)) # 工业用电（平段）（元/度）
# indu_ele_thr = db.Column(db.String(32)) # 工业用电（谷段）（元/度）
# resident_water_one = db.Column(db.String(32)) # 居民用水（一档）（元/吨）
# resident_water_two = db.Column(db.String(32)) # 居民用水（二档）（元/吨）
# resident_water_thr = db.Column(db.String(32)) # 居民用水（三档）（元/吨）
# comm_water = db.Column(db.String(32)) # 商业用水（元/吨）
# indu_water = db.Column(db.String(32)) # 工业用水（元/吨）
# special_water = db.Column(db.String(32)) # 特种用水（元/吨）
# resident_natgas_one = db.Column(db.String(32)) # 居民用气（一档）（元/m³）
# resident_natgas_two = db.Column(db.String(32)) # 居民用气（二档）（元/m³）
# resident_natgas_thr = db.Column(db.String(32)) # 居民用气（三档）（元/m³）
# sewage = db.Column(db.String(32)) # 污水处理（元/吨）
# wagelevel = db.Column(db.String(32)) # 最低工资标准（元/月）
# worker = db.Column(db.String(32)) # 普通员工（元/月）
# middlemag = db.Column(db.String(32)) # 中级管理人员（元/月）
# highmag = db.Column(db.String(32)) # 高层管理人员（元/月）
# # 环境配套
# dis_freight = db.Column(db.String(255)) # 距离货运站距离
# dis_rail = db.Column(db.String(255)) # 距离高铁站
# dis_port = db.Column(db.String(255)) # 距离港口距离
# dis_air = db.Column(db.String(255)) # 距离机场距离
# road_trans = db.Column(db.String(255)) # 公路运输
# rail_trans = db.Column(db.String(255)) # 铁路运输
# live_facility = db.Column(db.String(255)) # 园区生活配套
# market = db.Column(db.String(255)) # 百货商场
# hotel_bus = db.Column(db.String(255)) # 酒店商务
# medical = db.Column(db.String(255)) # 医疗机构
# education = db.Column(db.String(255)) # 学校教育
#
# induenterprise = db.Column(db.Text) # 规模以上企业
# innovate = db.Column(db.Text) # 科研机构
# base = db.Column(db.Text) # 双创基地
# carrier = db.Column(db.Text) # 产业载体
# url_file = db.Column(db.String(255)) # 文件路由
#
#
# # 区域要素管理下文件（文件和图片）
# class Gfile(BaseModel, db.Model):
# __tablename__ = "gfile"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name = db.Column(db.String(255), unique=True) # 文件名
# size = db.Column(db.String(255)) # 文件大小
# uperson = db.Column(db.String(255)) # 上传人
# cate = db.Column(db.Integer) # 文件类型，1文件，2图片
# url = db.Column(db.String(255)) # 文件本地地址
# garden_id = db.Column(db.Integer, db.ForeignKey("garden.id"))
# garden = db.relationship('Garden', backref=db.backref('document')) # 园区1-N文件、图片
#
#
# # 手机端项目搜索历史
# class SearchItem(db.Model):
# __tablename__ = "searchitem"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# history = db.Column(db.String(128)) # 用户搜索历史
# user_id = db.Column(db.Integer, db.ForeignKey("user.id")) # 用户外键
# section = db.relationship('User', backref=db.backref('searchitem')) # 用户-搜索
#
#
# # 太原给的，招商驾驶舱的企业数据（招商驾驶舱左上角）
# class ZCompany(db.Model):
# __tablename__ = "zcompany"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name = db.Column(db.String(255)) # 公司名称
# quality = db.Column(db.String(1)) # 公司类型 012345 （500-上市-规模-专精特新-高新-科技型中小）
# quality_name = db.Column(db.String(32)) # 公司类型名称
# district = db.Column(db.String(255)) # 区县名
# company_name = db.Column(db.String(255)) # 公司名称（）
#
#
# # class ZCollge(db.Model):
# # __tablename__ = "zcollege"
# #
# # id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# # name = db.Column(db.String(255)) # 公司名称
# # category = db.Column(db.String(1)) # 公司类型
# # category_name = db.Column(db.String(32)) # 公司类型名称
# # district = db.Column(db.String(255)) # 区县名
# # college_name = db.Column(db.String(255)) # 公司名称
# #
# #
# # class ZScientific(db.Model):
# # __tablename__ = "zscientific"
# #
# # id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# # name = db.Column(db.String(255)) # 机构名称
# # district = db.Column(db.String(255)) # 区县名
# # scientific_name = db.Column(db.String(255)) # 科研机构名称
# #
# #
# # class Zlab():
# # __tablename__ = "zlab"
# #
# # id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# # name = db.Column(db.String(255)) # 机构名称
# # district = db.Column(db.String(255)) # 区县名
# # lab_name = db.Column(db.String(255)) # 科研机构名称
#
# # 作战图
# class YearMonth(db.Model):
# __tablename__ = "year_month"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# year = db.Column(db.String(4)) # 年
# month = db.Column(db.String(2)) # 月
#
#
# # 对应zcompany的企业详情
# class ZhaoShang(db.Model):
# __tablename__ = "zhaoshang"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 企业
# company_name = db.Column(db.String(255)) # 企业名
# status = db.Column(db.String(32)) # 经营状态
# legal = db.Column(db.String(32)) # 发定代表人
# capital = db.Column(db.String(255)) # 注册资本,22万美元
# capital_nums = db.Column(db.Float) # 注册资本转换成人民币数值
# build_date = db.Column(db.DateTime) # 注册时间
# province = db.Column(db.String(32)) # 省
# city = db.Column(db.String(32)) # 市
# district = db.Column(db.String(32)) # 区
# lng = db.Column(db.String(100)) # 经度
# lat = db.Column(db.String(100)) # 纬度
# address = db.Column(db.String(255)) # 企业地址
# telephone = db.Column(db.Text) # 电话
# email = db.Column(db.Text) # 邮箱
# social_code = db.Column(db.String(100)) # 统一社会信用代码
# bao_num = db.Column(db.String(32)) # 参保人数
# entype = db.Column(db.String(100)) # 企业类型
# company_industry = db.Column(db.String(100)) # 所属行业
# web_site = db.Column(db.String(255)) # 企业网址
# business_scope = db.Column(db.Text) # 企业经营范围
#
# isfive = db.Column(db.String(32)) # 是否中国500强
#
# scale = db.Column(db.String(32)) # 规模以上企业
# zjtg = db.Column(db.String(32)) # 山西专精特工企业
# high_new = db.Column(db.String(32)) # 是否高新技术企业
# tbe = db.Column(db.String(32)) # 是否科技型中小企业
# quoted_company = db.Column(db.String(32)) # 是否上市企业
#
# induzone = db.Column(db.String(255)) # 所在园区
# company_info = db.Column(db.Text) # 公司简介
# product = db.Column(db.String(255)) # 产品
# takingn = db.Column(db.Float) # 营收
\ No newline at end of file
apps/radar/__init__.py 0 → 100644
from flask import Blueprint
# 创建蓝图对象
api_radar = Blueprint("api_radar", __name__)
from . import view
'''招商雷达'''
apps/radar/view.py 0 → 100644
import json
import requests
import math
from flask import current_app, request, jsonify
from apps.radar import api_radar
from apps.models import *
from sqlalchemy import extract, or_, and_
from sqlalchemy.sql import func
from apps.util import login_required
from apps.utils.response_code import RET
from datetime import datetime
import datetime
from apps import db, constants, redis_store
from apps.utils.neo4j_conn import conn_neo4j
graph = conn_neo4j()
# 具体类型企业列表查询
@api_radar.route("/enterList", methods=["POST"])
def newList():
'''查看企业列表——外加详情'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
area = req_dict.get("area") # [省，市，区]
if len(area) == 3:
province = area[0]
city = area[1]
district = area[2]
else:
province = ""
city = ""
district = ""
product = req_dict.get("product") # 企业产品
select = req_dict.get("select") # 企业列表选择 1234567 瞪羚-高新-科技型中小企业-上市-融资-独角兽-全部
page = req_dict.get("page")
perpage = req_dict.get("perpage")
name = req_dict.get("name")
if not all([inid, select, page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数错误")
try:
if inid:
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
if province:
enterprise = enterprise.filter_by(province=province)
if city:
enterprise = enterprise.filter_by(city=city)
if district:
enterprise = enterprise.filter_by(district=district)
if product:
# 有可能会变成模糊查询
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
if name:
# 有可能会变成模糊查询
enterprise = enterprise.filter(Enterprise.company_name.like("%{}%".format(name)))
if select == "1": # 瞪羚
remind = "瞪羚企业"
enterprise = enterprise.filter_by(dengl="1")
elif select == "2": # 高新
remind = "高新技术企业"
enterprise = enterprise.filter_by(high_new="1")
elif select == "3": # 科技型中小企业
remind = "科技型中小企业"
enterprise = enterprise.filter_by(tbe="1")
elif select == "4": # 上市
remind = "上市企业"
enterprise = enterprise.filter_by(quoted_company="1")
elif select == "5": # 融资
remind = "融资企业"
enterprise = enterprise.filter_by(fianacing="1")
elif select == "6": # 独角兽
remind = "独角兽企业"
enterprise = enterprise.filter_by(unicorn="1")
else:
remind = ""
enterprise = enterprise
size = enterprise.count()
enters = enterprise.paginate(page, perpage).items
enter = [{"id": i.id,
"name": i.company_name,
"industry": i.company_industry if i.company_industry else "-", # 行业
"build_date": str(i.build_date)[:10] if i.build_date else "-", # 时间
"capital": i.capital if i.capital else "-", # 注册资本
} for i in enters]
data = {"remind": remind, "enter": enter, "size": size}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 雷达监测页企业数量统计
@api_radar.route('/radar/enums', methods=['POST'])
# @login_required
def radar_enums():
'''雷达监测页企业数量统计'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
area = req_dict.get("area") # [省，市，区]
province = area[0]
city = area[1]
district = area[2]
product = req_dict.get("product") # 企业产品
# 校验参数完整性
if not all([inid]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
name_query = "radar" + str(inid) + str("".join(area)) + str(product)
if redis_store.get(name_query) is not None:
data = json.loads(redis_store.get(name_query))
return jsonify(code=RET.OK, msg="获取成功", data=data)
if inid:
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
if province:
enterprise = enterprise.filter_by(province=province)
if city:
enterprise = enterprise.filter_by(city=city)
if district:
enterprise = enterprise.filter_by(district=district)
if product:
# 有可能会变成模糊查询
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
nums_all = enterprise.count() # 企业总数
nums_dengl = enterprise.filter_by(dengl="1").count() # 瞪羚企业
nums_hignew = enterprise.filter_by(high_new="1").count() # 高新技术企业
nums_tbe = enterprise.filter_by(tbe="1").count() # 科技型中小企业
nums_quoted = enterprise.filter_by(quoted_company="1").count() # 上市企业
nums_financ = enterprise.filter_by(fianacing="1").count() # 有融资小企业
nums_unicorn = enterprise.filter_by(unicorn="1").count() # 独角兽企业
nums_capital = round(
float(enterprise.with_entities(func.sum(Enterprise.capital_nums)).scalar() if enterprise.with_entities(
func.sum(Enterprise.capital_nums)).scalar() else 0) / 10000, 2) # 注册资本（亿元）
nums_bao = enterprise.with_entities(func.sum(Enterprise.bao_num)).scalar() if enterprise.with_entities(
func.sum(Enterprise.bao_num)).scalar() else 0 # 就业人数
nums_patent = enterprise.with_entities(func.sum(Enterprise.num_patent)).scalar() if enterprise.with_entities(
func.sum(Enterprise.num_patent)).scalar() else 0 # 授权发明专利
data = {"nums_all": float(nums_all), "nums_capital": float(nums_capital), "nums_bao": float(nums_bao),
"nums_patent": float(nums_patent),
"nums_dengl": float(nums_dengl), "nums_hignew": float(nums_hignew), "nums_tbe": float(nums_tbe),
"nums_quoted": float(nums_quoted),
"nums_financ": float(nums_financ), "nums_unicorn": float(nums_unicorn), # "info": info
}
# redis缓存
redis_store.setex(name_query, 30 * 24 * 3600, json.dumps(data))
# redis_store.set(name_query, json.dumps(data))
# redis_store.expire(name_query, 30 * 24 * 3600)
print("redis")
return jsonify(code=RET.OK, msg="获取成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 雷达监测页企业数量趋势统计
@api_radar.route('/radar/tendency', methods=['POST'])
@login_required
def tendency():
'''雷达监测页企业数量统计'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
area = req_dict.get("area") # [省，市，区]
province = area[0]
city = area[1]
district = area[2]
product = req_dict.get("product") # 企业产品
sone = req_dict.get("sone") # 选择1，1企业个数，2注册资本
stwo = req_dict.get("stwo") # 选择2， 1年度，2季度，3月度
sthr = req_dict.get("sthr") # 选择3， 1新增量，2累积量
# 校验参数完整性
if not all([area, sone, stwo, sthr]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
name_query = "tendency" + str(inid) + str("".join(area)) + str(product) + str(sone) + str(stwo) + str(sthr)
if redis_store.get(name_query) is not None:
data = json.loads(redis_store.get(name_query))
return jsonify(code=RET.OK, msg="获取成功", data=data)
if inid:
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
if province:
enterprise = enterprise.filter_by(province=province)
if city:
enterprise = enterprise.filter_by(city=city)
if district:
enterprise = enterprise.filter_by(district=district)
if product:
# 有可能会变成模糊查询
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
# company = company.filter_by(product_all=product)
# yearn = datetime.datetime.now().year + 1 # 现在年份 固定成21
yearn = 2021 # 现在年份 固定成21
scope = [i for i in range(1980, yearn)] # 年份范围
months = [(1, 3), (4, 6), (7, 9), (10, 12)] # 季度
data = list()
if sthr == 1: # 新增量
if stwo == 1: # 年度，1980-2020
for year in scope:
result = enterprise.filter(extract("year", Enterprise.build_date) == year)
if sone == 1: # 企业个数
nums = result.count()
# data[year] = nums
data.append({"lable": year, "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[year] = round(cnums, 2) if cnums else 0
data.append({"lable": year, "value": round(cnums, 2) if cnums else 0})
elif stwo == 2: # 2020年季度(修改为5年季度)
for yea in range(2016, 2021):
for jd in range(len(months)):
result = enterprise.filter(and_(extract("year", Enterprise.build_date) == yea,
extract("month", Enterprise.build_date).between(months[jd][0],
months[jd][1])))
if sone == 1: # 企业个数
nums = result.count()
data.append({"lable": str(yea) + "-" + str(jd + 1), "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[(jd + 1)] = round(cnums, 2) if cnums else 0
data.append(
{"lable": str(yea) + "-" + str(jd + 1), "value": round(cnums, 2) if cnums else 0})
# for jd in range(len(months)):
# result = enterprise.filter(and_(extract("year", Enterprise.build_date) == (yearn - 1),
# extract("month", Enterprise.build_date).between(months[jd][0],
# months[jd][1])))
# if sone == 1: # 企业个数
# nums = result.count()
# # data[(jd + 1)] = nums
# data.append({"lable": (jd + 1), "value": nums})
# else: # 注册资本
# cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# # data[(jd + 1)] = round(cnums, 2) if cnums else 0
# data.append({"lable": (jd + 1), "value": round(cnums, 2) if cnums else 0})
elif stwo == 3: # 2020年月度（改为3年月度）
for yea in range(2018, 2021):
for m in range(2, 14, 2):
result = enterprise.filter(and_(extract("year", Enterprise.build_date) == yea,
extract("month", Enterprise.build_date) == m))
if sone == 1: # 企业个数
nums = result.count()
# data[m] = nums
data.append({"lable": str(yea) + "-" + str(m).rjust(2, "0"), "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[m] = round(cnums, 2) if cnums else 0
data.append({"lable": str(yea) + "-" + str(m).rjust(2, "0"),
"value": round(cnums, 2) if cnums else 0})
# for m in range(1, 13):
# result = enterprise.filter(and_(extract("year", Enterprise.build_date) == (yearn - 1),
# extract("month", Enterprise.build_date) == m))
# if sone == 1: # 企业个数
# nums = result.count()
# # data[m] = nums
# data.append({"lable": m, "value": nums})
# else: # 注册资本
# cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# # data[m] = round(cnums, 2) if cnums else 0
# data.append({"lable": m, "value": round(cnums, 2) if cnums else 0})
elif sthr == 2: # 累积量
if stwo == 1: # 年度，1980-2020
for year in scope:
result = enterprise.filter(extract("year", Enterprise.build_date) <= year)
if sone == 1: # 企业个数
nums = result.count()
# data[year] = nums
data.append({"lable": year, "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[year] = round(cnums, 2) if cnums else 0
data.append({"lable": year, "value": round(cnums, 2) if cnums else 0})
elif stwo == 2: # 2020年季度
for yea in range(2016, 2021):
for jd in range(len(months)):
result = enterprise.filter(and_(extract("year", Enterprise.build_date) == yea,
extract("month", Enterprise.build_date) <= months[jd][1]))
if sone == 1: # 企业个数
nums = result.count()
# data[(jd + 1)] = nums
data.append({"lable": str(yea) + "-" + str(jd + 1), "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[(jd + 1)] = round(cnums, 2) if cnums else 0
data.append(
{"lable": str(yea) + "-" + str(jd + 1), "value": round(cnums, 2) if cnums else 0})
# for jd in range(len(months)):
# result = enterprise.filter(and_(extract("year", Enterprise.build_date) == (yearn - 1),
# extract("month", Enterprise.build_date) <= months[jd][1]))
# if sone == 1: # 企业个数
# nums = result.count()
# # data[(jd + 1)] = nums
# data.append({"lable": (jd + 1), "value": nums})
# else: # 注册资本
# cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# # data[(jd + 1)] = round(cnums, 2) if cnums else 0
# data.append({"lable": (jd + 1), "value": round(cnums, 2) if cnums else 0})
elif stwo == 3: # 2020年月度
for yea in range(2018, 2021):
for m in range(2, 14, 2):
result = enterprise.filter(and_(extract("year", Enterprise.build_date) == yea,
extract("month", Enterprise.build_date) <= m))
if sone == 1: # 企业个数
nums = result.count()
# data[m] = nums
data.append({"lable": str(yea) + "-" + str(m).rjust(2, "0"), "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
data.append({"lable": str(yea) + "-" + str(m).rjust(2, "0"),
"value": round(cnums, 2) if cnums else 0})
# for m in range(1, 13):
# result = enterprise.filter(and_(extract("year", Enterprise.build_date) == (yearn - 1),
# extract("month", Enterprise.build_date) <= m))
# if sone == 1: # 企业个数
# nums = result.count()
# # data[m] = nums
# data.append({"lable": m, "value": nums})
# else: # 注册资本
# cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data.append({"lable": m, "value": round(cnums, 2) if cnums else 0})
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
# redis缓存
redis_store.setex(name_query, 30 * 24 * 3600, json.dumps(data))
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 雷达监测页企业top10
'''
1055 Expression #1 of SELECT list is not in GROUP BY clause and contains nonaggregated
解决办法：删除ONLY_FULL_GROUP_BY
SET GLOBAL sql_mode=(SELECT REPLACE(@@sql_mode,'ONLY_FULL_GROUP_BY',''));
/*
修改my.ini:
sql_mode=NO_ENGINE_SUBSTITUTION
*/
SELECT @@GLOBAL.SQL_mode;
SET @@GLOBAL.sql_mode=
'STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION';
SET @@GLOBAL.sql_mode="NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION";
'''
@api_radar.route('/radar/topt', methods=['POST'])
# @login_required
def topt():
'''雷达监测页企业top10'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
area = req_dict.get("area") # [省，市，区]
province = area[0]
city = area[1]
district = area[2]
product = req_dict.get("product") # 企业产品
select = req_dict.get("select") # 1--上市 2--专利数量 3--500强
# 校验参数完整性
if not all([area]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid:
enterprise = Enterprise.query.filter_by(c_type=int(inid))
else:
enterprise = Enterprise.query.filter_by()
# enterprise = Enterprise.query.filter_by(c_type=inid)
if province:
enterprise = enterprise.filter_by(province=province)
if city:
enterprise = enterprise.filter_by(city=city)
if district:
enterprise = enterprise.filter_by(district=district)
if product:
# 有可能会变成模糊查询
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
# company = company.filter_by(product_all=product)
if select == 1: # 上市
company = enterprise.filter_by(quoted_company=1).group_by(Enterprise.company_name,
Enterprise.takingn).order_by(
Enterprise.takingn.desc()).limit(10).all()
print(company)
if company:
# print(company[0].takingn)
sums = float(company[0].takingn if company[0].takingn else 1)
data = [
{"company_name": item.company_name,
"sum_money": str(int((float(item.takingn) if item.takingn else 0) / 10)) + '万元',
"h_sum": str((int(float(item.takingn) if item.takingn else 0) / sums) * 100)[:5] + "%"
} for item in company]
return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
return jsonify(code=RET.OK, msg="获取成功", data=[])
# return jsonify(code=RET.OK, msg="获取成功", data=[])
elif select == 2: # 专利数量
company = enterprise.group_by(Enterprise.company_name, Enterprise.num_patent).order_by(
Enterprise.num_patent.desc()).limit(10).all()
if company:
sums = float(company[0].num_patent if company[0].num_patent else 1)
data = [
{"company_name": item.company_name,
"sum_money": str(int(int(item.num_patent if item.num_patent else 0) / 10)) + '个',
"h_sum": str((int(float(item.num_patent if item.num_patent else 0)) / sums) * 100)[:5] + "%"
} for item in company
]
return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
return jsonify(code=RET.OK, msg="获取成功", data=[])
elif select == 3: # 500强
company = enterprise.filter_by(isfive=1).group_by(Enterprise.company_name, Enterprise.takingn).order_by(
Enterprise.takingn.desc()).limit(10).all()
if company:
# print(company[0].takingn)
sums = float(company[0].takingn if company[0].takingn else 1)
data = [
{"company_name": item.company_name,
"sum_money": str(int((float(item.takingn) if item.takingn else 0) / 10)) + '万元',
"h_sum": str((int(float(item.takingn) if item.takingn else 0) / sums) * 100)[:5] + "%"
} for item in company]
return jsonify(code=RET.OK, msg="获取成功", data=data)
# if company:
# for i in company:
# print(i.num_patent)
# sums = float(company[0].num_patent if company[0].num_patent else 1)
# print(sums)
# data = [
# {"company_name": item.company_name,
# "sum_money": str(int(int(item.num_patent if item.num_patent else 0) / 10)) + '个',
# "h_sum": str((int(float(item.num_patent if item.num_patent else 0)) / sums) * 100)[:5] + "%"
# } for item in company
# ]
# return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
return jsonify(code=RET.OK, msg="获取成功", data=[])
else:
return jsonify(code=RET.DATAERR, msg="参数错误", data=[])
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 雷达监测页企业属性分布统计
@api_radar.route('/radar/distribute', methods=['POST'])
# @login_required
def distribute():
'''雷达监测页企业属性分布统计'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
area = req_dict.get("area") # [省，市，区]
province = area[0]
city = area[1]
district = area[2]
product = req_dict.get("product") # 企业产品
# 校验参数完整性
if not all([area]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid:
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
if province:
enterprise = enterprise.filter_by(province=province)
if city:
enterprise = enterprise.filter_by(city=city)
if district:
enterprise = enterprise.filter_by(district=district)
if product:
# 有可能会变成模糊查询
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
# 企业类型
types = enterprise.with_entities(Enterprise.entype).distinct().all()
types = [item[0] for item in types if item[0]]
data_1 = list()
for i in types:
c_num = enterprise.filter_by(entype=i).count()
data_1.append({"name": i, "value": c_num})
# data_1 = {k: round(v / sum(data_1.values()), 2) for k, v in data_1.items()}
# 币种,不能为空
types = enterprise.with_entities(Enterprise.money_type).distinct().all()
types = [item[0] for item in types if item[0]]
data_2 = list()
for i in types:
c_num = enterprise.filter_by(money_type=i).count()
data_2.append({"name": i, "value": c_num})
# data_2 = {k: round(v / sum(data_2.values()), 2) for k, v in data_2.items()}
# data_2 = {'人民币': 0.02, "None": 0.97, '美元': 0.01} # 正式数据不能为空，None不能以变量出现
# 成立时间分布yearid
types = enterprise.with_entities(Enterprise.yearid).distinct().all()
types = [item[0] for item in types if item[0]]
data_3 = list()
dic_year = {1: "1-3年", 2: "3-5年", 3: "5-8年", 4: "8-10年", 5: "10-15年", 6: "15年以上"}
for i in types:
if i in dic_year:
c_num = enterprise.filter_by(yearid=i).count()
data_3.append({"name": dic_year[i], "value": c_num})
# data_3 = {k: round(v / sum(data_3.values()), 2) for k, v in data_3.items()}
# 注册资本大小分布
types = enterprise.with_entities(Enterprise.capital_id).distinct().all()
types = [item[0] for item in types if item[0]]
data_4 = list()
dic_capital = {1: "100万以内", 2: "100-500万", 3: "500-1000万", 4: "1000-5000万", 5: "5000万-1亿", 6: "1亿以上"}
for i in types:
if i in dic_capital:
c_num = enterprise.filter_by(capital_id=i).count()
data_4.append({"name": dic_capital[i], "value": c_num})
# data_4 = {k: round(v / sum(data_4.values()), 2) for k, v in data_4.items()}
# 上市板块
plates = enterprise.with_entities(Enterprise.public_sector).distinct().all()
# types = [item[0] for item in types if item[0]]
data_5 = list()
for i in plates:
if i[0] == "空" or i[0] is None:
continue
c_num = enterprise.filter_by(public_sector=i[0]).count()
data_5.append({"name": i[0], "value": c_num})
# data_5 = {k: round(v / sum(data_5.values()), 2) for k, v in data_5.items()}
# 融资轮次分布（按融资轮次）
rounds = enterprise.with_entities(Enterprise.fianacing_rounds).distinct().all()
data_6 = list()
for i in rounds:
if i[0] == "空" or i[0] is None:
continue
c_num = enterprise.filter_by(fianacing_rounds=i[0]).count()
data_6.append({"name": i[0], "value": c_num})
# data_6 = {k: round(v / sum(data_6.values()), 2) for k, v in data_6.items()}
data = {"entype": data_1, # 企业类型
"currency": data_2, # 币种
"time_distribute": data_3, # 成立时间分布
"capital": data_4, # 注册资本分部
"sector": data_5, # 上市板块
"rounds": data_6} # 融资轮次
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 雷达评估页行业地区分数评估
@api_radar.route('/radar/evaluation', methods=['POST'])
# @login_required
def evaluation():
'''雷达监测页企业属性分布统计'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 二级行业id
area = req_dict.get("area") # [省，市，区]
province = area[0]
city = area[1]
district = area[2]
# 校验参数完整性
if not all([inid, area]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
edata = EvaluationData.query.filter_by(c_type=inid)
if province and not city:
edata = edata.filter_by(province=province).filter(EvaluationData.city.is_(None))
if province and city and not district:
edata = edata.filter_by(province=province, city=city).filter(EvaluationData.district.is_(None))
if province and city and district:
edata = edata.filter_by(province=province, city=city, district=district)
edata = edata.first()
if edata:
data = {"development": edata.development, # 发育度
"contribute": edata.contribute, # 贡献度
"innovate": edata.innovate, # 创新力
"growup": edata.growup, # 成长性
"capital": edata.capital, # 资本力
"general": edata.general} # 综合分
return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
data = {"development": 0,
"contribute": 0,
"innovate": 0,
"growup": 0,
"capital": 0,
"general": 0}
return jsonify(code=RET.NODATA, msg="无数据", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 雷达评估页行业地区优势薄弱缺失三环节数据
@api_radar.route('/radar/prolink', methods=['POST'])
# @login_required
def prolink():
'''雷达监测页企业属性分布统计'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
area = req_dict.get("area") # [省，市，区]
province = area[0]
city = area[1]
district = area[2]
link_type = req_dict.get("link_type") # 缺失环节1，薄弱环节2，优势环节3
page = req_dict.get("page") # page
perpage = req_dict.get("perpage") # perpage
# 校验参数完整性
if not all([inid, area, page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
edata = EvaluationNodeData.query.filter_by(c_type=inid)
if not province:
edata = edata.filter(EvaluationNodeData.province.is_(None)).filter(
EvaluationNodeData.city.is_(None)).filter(EvaluationNodeData.district.is_(None))
if province and not city:
edata = edata.filter_by(province=province).filter(EvaluationNodeData.city.is_(None)).filter(
EvaluationNodeData.district.is_(None))
if province and city and not district:
edata = edata.filter_by(province=province, city=city).filter(EvaluationNodeData.district.is_(None))
if province and city and district:
edata = edata.filter_by(province=province, city=city, district=district)
edata = edata.all()
if edata:
num = [math.ceil(i.score) if i.score else 0 for i in edata]
num.sort()
num = [i for i in num if i > 0]
cent = num[int(len(num) * 0.5)]
deletion = len([item for item in edata if item.score == 0])
bedness = len([item for item in edata if item.score > 0 and item.score <= cent])
goodness = len([item for item in edata if item.score > cent])
res = {
"deletion": deletion,
"goodness": goodness,
"bedness": bedness
}
if link_type == 1: # "缺失环节":
result_bylink = [item.product for item in edata if item.score == 0]
elif link_type == 2: # "薄弱环节":
result_bylink = [item.product for item in edata if item.score > 0 and item.score <= cent]
elif link_type == 3: # "优势环节":
result_bylink = [item.product for item in edata if item.score > cent]
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
df = result_bylink[(page - 1) * perpage:page * perpage]
data = {"df": df, "size": res}
return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
data = []
return jsonify(code=RET.NODATA, msg="暂无数据", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 产品描述及推荐
@api_radar.route('/randerSelect', methods=['GET'])
# @login_required
def rander_select():
data = [{"label": "太原", "value": "太原"}, {"label": "其它", "value": "其它"}]
return jsonify(code=RET.OK, msg="查询成功", data=data)
# 产品描述及推荐
@api_radar.route('/recommond', methods=['POST'])
# @login_required
def recommond():
'''
产品描述及企业推荐
:return:
'''
req_dict = request.get_json()
name = req_dict.get("name") # 产品名
page = req_dict.get("page")
perpage = req_dict.get("perpage")
select = req_dict.get("select") # 企业地址选择
# 校验参数完整性
if not all([name]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
# 产品描述
# product = ProductInfo.query.filter_by(name=name).first()
# info = product.info if product and product.info else "暂无详情"
enterprise = Enterprise.query.filter(Enterprise.product_all.like("%{}%".format(name)))
# print(enterprise.count())
# company = Company.query.filter_by()
# 不在太原市
if select == "太原":
enterprise = enterprise.filter(Enterprise.city == "太原市") # .order_by(Enterprise.hots.desc())
else:
enterprise = enterprise.filter(Enterprise.city != "太原市") # .order_by(Enterprise.hots.desc())
# 参保人数
# enterprise = enterprise.filter(Enterprise.bao_num >= 5)
# 500强(分组排序)
# enterprise = enterprise.group_by(Enterprise.isfive).order_by(Enterprise.isfive.desc())
# print(enterprise.count())
size = enterprise.count()
enterprise = enterprise.order_by(Enterprise.c_type, Enterprise.hots.desc()).paginate(page,
perpage).items # # 企业热度倒序
df = []
for com in enterprise:
df.append({"id": com.id,
"company_name": com.company_name,
"capital": com.capital if com.capital else "-",
"buildate": str(com.build_date)[:10] if com.build_date else "-",
"status": com.status if com.status else "-",
"hots": com.hots})
data = {"df": df, "info": "暂无详情", "size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
'''新增暂不考虑'''
# 创建body
def create_body(args_query, args_term):
body = {
"query": {
"bool": {
"must": [{"multi_match": {"query": "{}".format(args_query["query"]), # match_phrase来实现完全匹配查询。
"type": "phrase",
"fields": [
"product"
],
"slop": 0,
}
},
]
}
},
"from": 0,
"size": 10,
"sort": [],
"aggs": {},
"_source": ['company_name'],
}
for k, v in args_term.items():
body["query"]["bool"]["must"].append({"term": {"{}".format(k): "{}".format(v)}})
return body
# 通过节点判断优势薄弱和缺失，1优势、2薄弱、3缺失
def get_waa(pname_two, inid, area):
province = area[0]
city = area[1]
district = area[2]
try:
edata = EvaluationNodeData.query.filter_by(c_type=inid)
if not province:
edata = edata.filter(EvaluationNodeData.province.is_(None)).filter(
EvaluationNodeData.city.is_(None)).filter(EvaluationNodeData.district.is_(None))
if province and not city:
edata = edata.filter_by(province=province).filter(EvaluationNodeData.city.is_(None)).filter(
EvaluationNodeData.district.is_(None))
if province and city and not district:
edata = edata.filter_by(province=province, city=city).filter(EvaluationNodeData.district.is_(None))
if province and city and district:
edata = edata.filter_by(province=province, city=city, district=district)
edata = edata.all()
if edata:
num = [math.ceil(i.score) if i.score else 0 for i in edata]
num.sort()
num = [i for i in num if i > 0]
cent = num[int(len(num) * 0.5)]
youshi = [item.product for item in edata if item.score > cent] # 优势
queshi = [item.product for item in edata if item.score == 0] # 缺失
weak = [item.product for item in edata if item.score > 0 and item.score <= cent] # 薄弱
else:
youshi = [] # 优势
queshi = [] # 缺失
weak = [] # 薄弱
if pname_two in youshi:
return 1
if pname_two in weak:
return 2
if pname_two in queshi:
return 3
except Exception as e:
current_app.logger.error(e)
return 2
# 通过es全匹配查询三级
def find_thr_by_es(inid, name_query, relation, area):
if relation == "中游行业":
relation_c = "下位产品"
else:
relation_c = relation
args_term = dict() # 省市区条件
if area[0]:
args_term['province'] = area[0]
if area[1]:
args_term['city'] = area[1]
if area[2]:
args_term['district'] = area[2]
args_term['c_type'] = inid # 指定二级企业分类
url = "http://127.0.0.1:9200/ty_cur/_search"
sql_01 = "match (n) -[r:`{}`]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(relation_c, name_query)
res_zero = graph.run(sql_01).data()
res_one = list(set([i["m.name"] for i in list(res_zero)])) # 不重复的一级节点
data = {"clickable": False,
"node": "{}".format(relation[:2]),
"level": 1,
"subNodeList": [],
# "count": cnums
}
for it in res_one:
pname_one = it
# es全匹配查询企业数量
args_query = dict() # 产品
args_query["query"] = pname_one
body = create_body(args_query, args_term)
result_es = json.loads(requests.post(url=url, json=body).text)
erjicount = int(result_es["hits"]["total"])
node_one = {"clickable": True,
"node": "{}".format(pname_one),
"level": 2,
"count": erjicount,
"subNodeList": []
}
sql_02 = "match (n) -[r]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(pname_one)
result = graph.run(sql_02).data()
result = list(set([i["m.name"] for i in list(result)])) # 不重复的二级节点
for item in result:
pname_two = item
# es全匹配查询企业数量
args_query = dict() # 产品
args_query["query"] = pname_two
body = create_body(args_query, args_term)
result_es = json.loads(requests.post(url=url, json=body).text)
count2 = int(result_es["hits"]["total"])
# 二级节点
node_two = {"clickable": True,
"node": "{}".format(pname_two),
"level": 3,
"count": count2,
"subNodeList": [],
"waa": get_waa(pname_two, inid, area) # 1优势、2薄弱、3缺失
}
sql_03 = "match (n) -[r]->(m) WHERE n.name='{}' return n.name,r.type,m.name".format(pname_two)
result3 = graph.run(sql_03).data()
result3 = list(set([i["m.name"] for i in list(result3)])) # 不重复的三级节点
for itm in result3:
pname_thr = itm
args_query = dict() # 产品
args_query["query"] = pname_thr
body = create_body(args_query, args_term)
result_es = json.loads(requests.post(url=url, json=body).text)
count3 = int(result_es["hits"]["total"])
# 三级
node_thr = {"clickable": True,
"node": "{}".format(pname_thr),
"level": 4,
"count": count3,
"subNodeList": []
}
node_two["subNodeList"].append(node_thr)
node_one["subNodeList"].append(node_two)
data["subNodeList"].append(node_one)
return data
# 行业产品公司数量(链图)
@api_radar.route('/attract/chain', methods=['POST'])
# @login_required
def attract_chain():
'''行业id->行业链标题-》上中下游-》查询数值'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 二级行业id（二级行业显示链图）
area = req_dict.get("area") # ["","",""] 省市区
# 校验参数完整性
if not all([inid]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
name_query = "radar" + str(inid) + str("".join(area))
if redis_store.get(name_query) is not None:
data = json.loads(redis_store.get(name_query))
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 行业使用名
industryName = Industry.query.filter_by(nid=inid).first().oname
ptp = {"轨道交通": "轨道交通装备",
"新能源汽车": "新能源汽车整车制造",
"智能煤机": "智能煤机",
"数控机床及机器人": "数控机床及机器人",
"通用航空": "通用航空",
"智能电网": "智能电网",
"氢能": "氢能",
"碳基新材料": "碳基新材料",
"金属新材料": "金属新材料",
"煤化工新材料": "煤化工新材料",
"生物基新材料": "生物基新材料",
"信息技术应用创新": "信息创新技术",
"网络安全": "网络安全",
"云计算": "云计算产业",
"大数据及人工智能": "大数据及人工智能",
"物联网": "物联网",
"康养产业": "康养产业",
"生物制药": "生物制药",
"现代物流": "现代物流",
"现代金融": "现代金融",
"半导体及光电子": "半导体",
"节能环保": "节能环保"
}
if industryName in ptp:
industryName = ptp[industryName]
result = {
"industryChain": industryName,
"nodeList": [find_thr_by_es(inid, industryName, "上游行业", area),
find_thr_by_es(inid, industryName, "中游行业", area),
find_thr_by_es(inid, industryName, "下游行业", area)]
}
# redis缓存
redis_store.set(name_query, json.dumps(result))
redis_store.expire(name_query, 30 * 24 * 3600)
print("redis")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据异常")
return jsonify(code=RET.OK, msg="获取成功", data=result)
apps/user_pc/__init__.py 0 → 100644
from flask import Blueprint
# 创建蓝图对象
api_user = Blueprint("api_user", __name__)
from . import view
from . import view_other
'''用户登录页'''
apps/user_pc/view.py 0 → 100644
import datetime
import re
import json
import time
import random
import threading
import numpy as np
import requests
import filetype
from sqlalchemy.exc import IntegrityError
from flask_mail import Mail, Message
from flask import g, current_app, request, jsonify, session
from apps.user_pc import api_user
from apps import creat_app
from apps.utils.send_phone_info import send_code_new
from apps.utils.response_code import RET
from apps import db, constants, redis_store
from apps.models import *
from apps.util import create_token
from werkzeug.security import generate_password_hash, check_password_hash
from apps import qiniu_store
from apps.utils.vxconfig import WxConfig
from apps.utils.encrypt_decrypt.aes_cbc import encrypt, decrypt
# 给手机发验证码(2020-11-4)
@api_user.route("/send_mobile_code", methods=["POST"])
def send_phone_code():
'''
向手机发送验证码
:return:
'''
# 获取请求参数，转化字典
req_dict = request.get_json()
mobile = req_dict.get('mobile') # 手机号
# 校验参数完整性
if not all([mobile]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 校验手机号格式
if not re.match(r"1[23456789]\d{9}$", mobile):
return jsonify(code=RET.MOBILEERR, msg="手机号格式错误")
# # 判断手机号是否存在
# try:
# user = User.query.filter_by(mobile=mobile).first()
# except Exception as e:
# current_app.logger.error(e)
# else:
# if user: # 手机号已存在
# return jsonify(code=RET.DATAEXIST, msg="手机号已存在，请直接登录")
# 生成短信验证码
sms_code = "%06d" % random.randint(0, 999999)
data = send_code_new(mobile, sms_code)
# print(data)
if data['Message'] == 'OK':
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次出发发送短信的操作
redis_store.setex("send_sms_code_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="保存短信验证码异常")
# 发送成功
return jsonify(code=RET.OK, msg="发送成功")
else:
return jsonify(code=RET.THIRDERR, msg="发送失败")
# 手机验证码登录(2020-11-4)
@api_user.route("/login_bysms", methods=["POST"])
def login_bysms():
'''
用户验证码登录，用户存在，直接登陆，不存在就后台注册
:return:
'''
# 参数获取与校验
req_dict = request.get_json()
mobile = req_dict.get('mobile') # 手机号
sms_code = req_dict.get("sms_code") # 验证码
# 校验参数完整性
if not all([mobile, sms_code]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 校验手机号格式
if not re.match(r"1[23456789]\d{9}$", mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
# 获取短信验证码
try:
real_sms_code = redis_store.get('sms_code_{}'.format(mobile)).decode()
# real_sms_code = "123456"
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="redis数据库异常")
# 获取用户
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="获取用户信息失败")
# 判断用户填写短信验证码是否一致
if real_sms_code != sms_code:
# if "123456" != sms_code:
return jsonify(code=RET.DATAERR, msg="短信验证码错误")
# 删除redis中的短信验证码，防止重复校验
try:
redis_store.delete("sms_code_{}".format(mobile))
except Exception as e:
current_app.logger.error(e)
if not user:
# 判断并添加用户信息
try:
user = User(name=mobile, mobile=mobile, flag=1, status=1)
db.session.add(user)
db.session.commit()
except Exception as e:
# 表示操作失败，回滚数据库操作
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库异常")
# print(user.status==3)
if user.status == 3:
return jsonify(code=RET.USERERR, msg="当前用户被禁止登录,请联系管理员")
# 获取用户id，传入生成token的方法，并接收返回的token
token = create_token(user.id)
time = datetime.now()
current_app.logger.error(
'++++++++++++++++++++++++++++登录日志>>>{}:{}通过使用手机-短信验证码登录成功了！+++++++++++++++++++++++=++'.format(time, mobile))
return jsonify(code=RET.OK, msg="登录成功", token=token, flag=user.flag)
# # 异步邮箱发送信息
# def send_async_email(mail, app, msg):
# with app.app_context():
# mail.send(msg)
#
#
# # 给邮箱发验证码
# @api_user.route("/send_email_code", methods=["POST"])
# def send_email_code():
# '''
# 向邮箱送验证码
# :return:
# '''
# # 获取请求参数，转化字典
# req_dict = request.get_json()
# email = req_dict.get('email') # 邮箱号
# # 校验参数完整性
# if not all([email]):
# return jsonify(code=RET.PARAMERR, msg="参数不完整")
#
# # 校验邮箱格式
# if not re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", email):
# return jsonify(code=RET.PARAMERR, msg="邮箱格式错误")
#
# # print(email)
# app = creat_app('product')
# mail = Mail(app)
# sms_code = "%06d" % random.randint(0, 999999)
#
# msg = Message("中研认知产业链在线,欢迎您！", recipients=[email])
# msg.body = "【中研认知产业链在线】您的验证码为：{}，您正在进行邮箱绑定，如非本人操作，请忽略本邮件！".format(sms_code)
# thread = threading.Thread(target=send_async_email, args=(mail, app, msg))
# thread.start()
# try:
# redis_store.setex("ems_code_%s" % email, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# # 保存发送给这个邮箱的记录，防止用户在180s内再次出发发送短信的操作
# redis_store.setex("send_ems_code_%s" % email, constants.SEND_EMS_CODE_INTERVAL, 1)
# except Exception as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="保存验证码异常")
#
# return jsonify(code=RET.OK, msg="发送成功")
''''''
# 注册页面选择选择单位(2020-11-4)
@api_user.route('/orgs', methods=['GET'])
def zcorgs():
'''
太原市企业条件选择导航获取
:return:
'''
try:
gover = Government.query.all()
ty = Government.query.get(1)
sections = ty.sections
data = [{"label": i.name, "value": i.id} for i in gover]
section = [{"label": i.name, "value": i.id} for i in sections]
orgs = {"data": data, "section": section}
return jsonify(code=RET.OK, msg="获取成功", orgs=orgs)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 注册（2020-11-4）
@api_user.route("/register", methods=["POST"])
def register():
"""
用户注册
:return:
"""
# 获取请求参数，转化字典
req_dict = request.get_json()
real_name = req_dict.get("real_name") # 姓名
age = req_dict.get("age") # 年龄
sex = req_dict.get("sex") # 性别
mobile = req_dict.get('mobile') # 手机号
sms_code = req_dict.get("sms_code") # 验证码
name = req_dict.get("name") # 用户名
password = req_dict.get("password") # 密码
password_again = req_dict.get("repassword") # 密码2
position = req_dict.get("position") # 职务
unit = req_dict.get("unit") # 机构/单位
section = req_dict.get("section") # 所在部门（政府）
# 校验参数完整性
if not all([real_name, age, sex, mobile, sms_code, name, unit, position, password, password_again]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 校验手机号格式
if not re.match(r"1[23456789]\d{9}$", mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
# 获取短信验证码
try:
real_sms_code = redis_store.get('sms_code_{}'.format(mobile)).decode()
# real_sms_code = "123456"
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.NODATA, msg="短信验证码失效")
# 判断短信验证码是否失效
if not redis_store:
return jsonify(code=RET.NODATA, msg="短信验证码失效")
# 删除redis中的短信验证码，防止重复校验
try:
redis_store.delete("sms_code_{}".format(mobile))
except Exception as e:
current_app.logger.error(e)
# 判断用户填写短信验证码是否一致
if real_sms_code != sms_code:
# if "123456" != sms_code:
return jsonify(code=RET.DATAERR, msg="短信验证码错误")
# 用户名唯一(字母开头，长度4-15)
try:
patten = "^[a-zA-Z][\w]*[\w]*$"
if re.match(patten, name) and re.match(patten, name).string == name:
user = User.query.filter_by(name=name).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="用户名已存在")
else:
return jsonify(code=RET.DATAERR, msg="用户名格式错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="用户名格式错误")
# 校验密码
if password != password_again:
return jsonify(code=RET.DATAERR, msg="密码不一致")
# 增加密码校验策略，20211109
# 判断密码长度是否8位，数字、字母、特殊字符同时存在，能使用用户名、连续性字母、数字、特殊字符等易猜测口令。
if len(password) < 8:
return jsonify(code=RET.DATAERR, msg="密码长度最少为8位")
# 密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'
if not (re.search(r'\d+', password) and re.search(r'[a-z]+', password) and re.search(r'[A-Z]+',password) and re.search(r'[!@#$%^&*()_+=-]+', password)):
return jsonify(code=RET.DATAERR, msg="密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'")
# 密码不能使用用户名
if password == name:
return jsonify(code=RET.DATAERR, msg="密码存在风险，不能与用户名相同！")
# 判断并添加用户信息
try:
ouser = User.query.filter_by(mobile=mobile).first()
print(ouser)
if ouser and ouser.flag == 1 and ouser.status != 1: # 外部访客被禁止
return jsonify(code=RET.DATAEXIST, msg="当前用户被禁止，请联系管理员")
if ouser and ouser.flag == 2 and ouser.status == 2: # 注册暂时未通过
return jsonify(code=RET.DATAEXIST, msg="手机号已注册,请耐心等待审核")
if ouser and ouser.flag == 2 and ouser.status == 1: # 内部用户再次注册
return jsonify(code=RET.DATAEXIST, msg="手机号已注册,请勿重复注册")
if ouser and ouser.flag == 1 and ouser.status == 1: # 外部访客注册
ouser.real_name = real_name
ouser.age = age
ouser.sex = sex
ouser.mobile = mobile
ouser.unit = unit
ouser.position = position
ouser.name = name
ouser.flag = 2
ouser.status = 2
if section:
ouser.section = section
ouser.password = password
# return jsonify(code=RET.DATAEXIST, msg="手机号已存在,请勿重复注册")
else:
user = User(real_name=real_name, age=age, sex=sex, mobile=mobile, unit=unit, position=position, name=name,
flag=2, status=2)
if section:
user.section = section
user.password = password
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库异常")
# except IntegrityError as e:
# current_app.logger.error(e)
# return jsonify(code=RET.DBERR, msg="手机号已被使用，请勿重复注册")
return jsonify(code=RET.OK, msg="注册成功，请等待工作人员的审核，通常为3-7个工作日")
# 内部用户手机-密码登录 (2020-11-4)
@api_user.route("/login_bypwd", methods=["POST"])
def login_bypwd():
'''
用户密码登录
:return:
'''
# 参数获取与校验
req_dict = request.get_json()
# 解密
param = req_dict.get("param") # 揭秘参数
req_dict = json.loads(decrypt(param))
mobile = req_dict.get('mobile')
password = req_dict.get('password')
# 校验参数完整性
if not all([mobile, password]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 校验手机号格式
if not re.match(r"1[23456789]\d{9}$", mobile):
return jsonify(code=RET.PARAMERR, msg="手机号错误")
# 判断错误次数是否超过限制，如果超过则10分钟内禁止此IP登录
user_ip = request.remote_addr
print("IP地址：", user_ip)
# 获取ip的锁定时间
try:
access_nums = redis_store.get('access_nums_{}'.format(user_ip))
if access_nums:
if int(access_nums.decode()) >= constants.LOGIN_ERROR_TIMES:
lock_time = redis_store.ttl('access_nums_{}'.format(user_ip))
return jsonify(code=RET.LOCKTIME, msg="ip锁定倒计时中.....", lock_time = lock_time)
except Exception as e:
current_app.logger.error(e)
else:
pass
try:
access_nums = redis_store.get('access_nums_{}'.format(user_ip))
# access_nums = "123456"
except Exception as e:
current_app.logger.error(e)
else:
if access_nums:
if int(access_nums.decode()) >= constants.LOGIN_ERROR_TIMES:
return jsonify(code=RET.REQERR, msg="错误次数过多，请15分钟后重试！",time=constants.LOGIN_ERROR_FORBID_TIME)
# 验证手机号与密码
try:
user = User.query.filter_by(mobile=mobile, flag=2).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DATAERR, msg="获取用户信息失败")
if not user:
return jsonify(code=RET.DATAERR, msg="账户不存在")
# 将用户名与密码验证放置在一处，若失败返回提示信息并记录次数
if not user.check_password(password):
try:
redis_store.incr('access_nums_{}'.format(user_ip))
redis_store.expire('access_nums_{}'.format(user_ip), constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DATAERR, msg="密码错误")
if user.status == 2: # 审核
return jsonify(code=RET.ROLEERR, msg="审核暂未通过,请以外部访客身份登陆")
if user.status == 3: # 驳回
return jsonify(code=RET.ROLEERR, msg="您的审核未通过，请联系工作人员")
session.permanent = True # 设置session在设定时间内有效 注意这个要设置在request里边 即请求内部
# 若成功保存登录状态
token = create_token(user.id)
time = datetime.now()
current_app.logger.error('++++++++++++++++++++++++++++登录日志>>>{}:{}通过使用手机-密码登录成功了！+++++++++++++++++++++++=++'.format(time,mobile))
return jsonify(code=RET.OK, msg="登录成功", token=token,flag=user.flag)
''''''
# 微信授权
@api_user.route("/login_byvx", methods=["POST"])
def login_byvx():
'''
用户验证码登录，用户存在，直接登陆，不存在就后台注册
:return:
'''
# 参数获取与校验
req_dict = request.get_json()
code = req_dict.get('code') # 微信登录code
# 校验参数完整性
if not all([code]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
app_id = WxConfig.get_wx_app_id()
app_secret = WxConfig.get_wx_app_secret()
url = u'https://api.weixin.qq.com/sns/oauth2/access_token'
params = {
'appid': app_id,
'secret': app_secret,
'code': code,
'grant_type': 'authorization_code'
}
res = requests.get(url, params=params).json()
user_info_url = u'https://api.weixin.qq.com/sns/userinfo'
params1 = {
'access_token': res.get("access_token"),
'openid': res.get("openid")
}
uinfo = requests.get(user_info_url, params=params1).json()
# nickname = uinfo.get('nickname').encode('iso8859-1').decode('utf-8')
try:
openid = uinfo["openid"]
unionid = uinfo["unionid"]
except:
return None
try:
user = User.query.filter_by(vxopenid=openid, vxunionid=unionid).first()
if user:
# 若成功保存登录状态
token = create_token(user.id)
return jsonify(code=RET.OK, msg="登录成功", token=token,flag=user.flag)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="appid,secreat异常")
time = datetime.now()
current_app.logger.error(
'++++++++++++++++++++++++++++登录日志>>>{}:{}通过使用微信登录成功了！+++++++++++++++++++++++=++'.format(time, user))
return jsonify(code=RET.USERERR, msg="授权成功", user_info=uinfo)
# vx登陆后绑定手机号
@api_user.route("/binding", methods=["POST"])
def binding():
'''
绑定已有账号
:return:
'''
req_dict = request.get_json()
openid = req_dict.get("openid") # vxopenid
unionid = req_dict.get("unionid") # vxunionid
mobile = req_dict.get('mobile') # 手机号
sms_code = req_dict.get("sms_code") # 验证码
# 校验参数完整性
if not all([openid, unionid, mobile, sms_code]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 校验手机号格式
if not re.match(r"1[23456789]\d{9}$", mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
# 获取短信验证码
try:
real_sms_code = redis_store.get('sms_code_{}'.format(mobile)).decode()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="redis数据库异常")
# 获取用户
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="获取用户信息失败")
# 判断用户填写短信验证码是否一致
if real_sms_code != sms_code:
return jsonify(code=RET.DATAERR, msg="短信验证码错误")
# 删除redis中的短信验证码，防止重复校验
try:
redis_store.delete("sms_code_{}".format(mobile))
except Exception as e:
current_app.logger.error(e)
try:
if user:
user.vxopenid = openid
user.vxunionid = unionid
db.session.commit()
if user.status != 1:
jsonify(code=RET.OK, msg="绑定成功，当前用户被禁止登录,请联系管理员")
else:
user = User(name=mobile, mobile=mobile, vxopenid=openid, vxunionid=unionid, flag=1, status=1)
# user.password = password
db.session.add(user)
db.session.commit()
except Exception as e:
# 表示操作失败，回滚数据库操作
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库异常")
# 若成功保存登录状态
token = create_token(user.id)
return jsonify(code=RET.OK, msg="绑定成功，登录成功", token=token,flag=user.flag)
# 后台用户账号密码
@api_user.route("/backLogin", methods=["POST"])
def back_login():
'''
用户密码登录
:return:
'''
# 参数获取与校验
req_dict = request.get_json()
# 解密
param = req_dict.get("param") # 揭秘参数
req_dict = json.loads(decrypt(param))
name = req_dict.get('name')
password = req_dict.get('password')
# 校验参数完整性
if not all([name, password]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 判断错误次数是否超过限制，如果超过则10分钟内禁止此IP登录
user_ip = request.remote_addr
# print("IP地址：", user_ip)
try:
access_nums = redis_store.get('access_nums_{}'.format(user_ip))
except Exception as e:
current_app.logger.error(e)
else:
if access_nums:
if int(access_nums.decode()) >= constants.LOGIN_ERROR_TIMES:
return jsonify(code=RET.REQERR, msg="错误次数过多，请稍候重试")
# 验证账户与密码
try:
user = Bstage.query.filter_by(name=name).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="获取用户信息失败")
# 将用户名与密码验证放置在一处，若失败返回提示信息并记录次数
if (not user) or (not user.check_password(password)):
# if (not user) or (password != "123"):
try:
redis_store.incr('access_nums_{}'.format(user_ip))
redis_store.expire('access_nums_{}'.format(user_ip), constants.LOGIN_ERROR_FORBID_TIME)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="密码错误")
# 若成功保存登录状态和管理员的角色id
token = create_token(user.id)
time = datetime.now()
current_app.logger.error(
'++++++++++++++++++++++++++++登录日志>>>{}:{}通过后台登录成功了！+++++++++++++++++++++++=++'.format(time, name))
return jsonify(code=RET.OK, msg="登录成功", token=token,flag=3)
apps/user_pc/view_other.py 0 → 100644
import re
import random
import threading
from flask import jsonify, request, current_app
from flask_mail import Mail, Message
from apps import redis_store, creat_app
from apps.user_pc import api_user
from apps.models import *
from apps.utils.response_code import RET
from apps.util import login_required, verify_token
from apps.utils.send_phone_info import send_code_new
# 全国企业的收藏，可能存在问题，企业实体数
@api_user.route("/user_code", methods=["POST"])
def user_code():
# 获取请求参数，转化字典
req_dict = request.get_json()
mobile = req_dict.get('mobile')
if not all([mobile]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
if not re.match(r'^1[3456789]\d{9}$', mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
sms_code = "%06d" % random.randint(0, 999999)
data = send_code_new(mobile, sms_code)
if data['Message'] == 'OK':
# 保存真实的短信验证码
try:
redis_store.setex("sms_code_%s" % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个手机号的记录，防止用户在60s内再次出发发送短信的操作
redis_store.setex("send_sms_code_%s" % mobile, constants.SEND_SMS_CODE_INTERVAL, 60)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="保存短信验证码异常")
# 发送成功
return jsonify(code=RET.OK, msg="发送成功")
else:
return jsonify(code=RET.THIRDERR, msg="发送失败")
# 异步邮箱发送信息
def send_async_email(mail, app, msg):
with app.app_context():
mail.send(msg)
@api_user.route("/phoneChange", methods=["POST"])
@login_required
def phone_change():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user_information = User.query.get(user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
req_dict = request.get_json()
mobile = req_dict.get("mobile")
sms_code = req_dict.get("sms_code")
user_information.mobile = mobile
sms_code = sms_code
print(sms_code)
# 校验手机号格式
if not re.match(r'^1[3456789]\d{9}$', user_information.mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
if not redis_store.get('sms_code_{}'.format(user_information.mobile)):
return jsonify(code=RET.DATAERR, msg="请获取验证码")
# 获取短信验证码
try:
real_sms_code = redis_store.get('sms_code_{}'.format(user_information.mobile)).decode()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="redis数据库异常")
# 判断短信验证码是否失效
if not redis_store:
return jsonify(code=RET.NODATA, msg="短信验证码失效")
# 删除redis中的短信验证码，防止重复校验
try:
redis_store.delete("sms_code_{}".format(user_information.mobile))
except Exception as e:
current_app.logger.error(e)
# 判断用户填写短信验证码是否一致
if real_sms_code != sms_code:
return jsonify(code=RET.DATAERR, msg="短信验证码错误")
try:
exist = User.query.filter_by(mobile=mobile).first()
if exist:
return jsonify(code=RET.DATAEXIST, msg="手机号已存在")
user.mobile = mobile
db.session.commit()
return jsonify(code=RET.OK, msg="手机号更改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
@api_user.route("/changepassword", methods=["POST"])
@login_required
def change_password():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
# 原密码是否正确
req_dic = request.get_json()
password = req_dic.get("password")
re_pas = req_dic.get("repassword")
new_pas = req_dic.get("newpass")
# 密码长度
if len(new_pas) < 6:
return jsonify(code=RET.DATAERR, msg="密码太短，不安全")
# 两次密码是否一致
if new_pas != re_pas:
return jsonify(code=RET.PARAMERR, msg="两次密码不一致")
# 判断密码长度是否8位，数字、字母、特殊字符同时存在，能使用用户名、连续性字母、数字、特殊字符等易猜测口令。
if len(new_pas) < 8:
return jsonify(code=RET.DATAERR, msg="密码长度最少为8位")
# 密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'
if not (re.search(r'\d+', new_pas) and re.search(r'[a-z]+', new_pas) and re.search(r'[A-Z]+',
new_pas) and re.search(
r'[!@#$%^&*()_+=-]+', new_pas)):
return jsonify(code=RET.DATAERR, msg="密码应设置为包含大小写字母、数字、特殊符号'!@#$%^&*()_+=-'")
# 两个密码是否都存在
if not all([new_pas, re_pas, password]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user_information = User.query.get(user_id)
if not check_password_hash(user_information.password_hash, password):
return jsonify(code=RET.DATAERR, msg="密码错误")
user_information.password = new_pas
db.session.commit()
return jsonify(code=RET.DBERR, msg="更改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 给邮箱发验证码
@api_user.route("/email_code", methods=["POST"])
def send_email_code():
'''
向邮箱送验证码
:return:
'''
# 获取请求参数，转化字典
req_dict = request.get_json()
email = req_dict.get('email') # 邮箱号
# 校验参数完整性
if not all([email]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 校验邮箱格式
if not re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", email):
return jsonify(code=RET.PARAMERR, msg="邮箱格式错误")
# print(email)
# app = creat_app('product')
app = creat_app('develop')
mail = Mail(app)
sms_code = "%06d" % random.randint(0, 999999)
msg = Message("中研认知产业链在线,欢迎您！", recipients=[email])
msg.body = "【中研认知产业链在线】您的验证码为：{}，您正在进行邮箱绑定，如非本人操作，请忽略本邮件！".format(sms_code)
thread = threading.Thread(target=send_async_email, args=(mail, app, msg))
thread.start()
try:
redis_store.setex("sms_code_%s" % email, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# 保存发送给这个邮箱号的记录，防止用户在60s内再次出发发送短信的操作
redis_store.setex("send_sms_code_%s" % email, constants.SEND_SMS_CODE_INTERVAL, 60)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="保存验证码异常")
print(redis_store.get('sms_code_{}'.format(email)))
return jsonify(code=RET.OK, msg="发送成功")
@api_user.route("/changeEmail", methods=["POST"])
@login_required
def change_email():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dic = request.get_json()
email = req_dic.get("email")
email_code = req_dic.get("email_code")
try:
user_information = User.query.get(user_id)
if not all([email, email_code]):
return jsonify(code=RET.PARAMERR, msg="参数不全")
if email:
user_information.email = email
if not email_code:
return jsonify(code=RET.NODATA, msg="验证码不能为空")
if not re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$",
user_information.email):
return jsonify(code=RET.PARAMERR, msg="邮箱格式错误")
# 获取邮箱验证码
try:
real_sms_code = redis_store.get('sms_code_{}'.format(user_information.email)).decode()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="redis数据库异常")
# 判断邮箱验证码是否失效
if not redis_store:
return jsonify(code=RET.NODATA, msg="短信验证码失效")
# 删除redis中的邮箱验证码，防止重复校验
try:
redis_store.delete("sms_code_{}".format(user_information.email))
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="redis数据库异常")
# 判断用户填写短信验证码是否一致
if real_sms_code != email_code:
return jsonify(code=RET.DATAERR, msg="邮箱验证码错误")
db.session.commit()
return jsonify(code=RET.OK, msg="更改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
@api_user.route("/detail", methods=["GET"])
@login_required
def detail():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user_information = User.query.get(user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
data = {
"flag": user.flag,
"real_name": user_information.real_name, # 名字
"age": user_information.age, # 年龄
"sex": user_information.sex, # 性别
"mobile": user_information.mobile, # 手机号
"username": user_information.name, # 用户名
"email": user_information.email, # 邮箱
"section": user_information.section if user_information.section else "-", # 部门
"position": user_information.position if user_information.position else "-", # 职务
"level": user_information.level if user_information.level else "-", # 职级
"unit": user_information.unit if user_information.unit else "-", # 所在机构
"funct": user_information.function if user_information.function else "-", # 工作职能
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
@api_user.route("/personal", methods=["POST"])
@login_required
def personal():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.get_json()
real_name = req_dict.get("real_name")
age = req_dict.get("age")
sex = req_dict.get("sex")
name = req_dict.get("name")
try:
user_information = User.query.get(user_id)
# 姓名
if real_name:
user_information.real_name = real_name
# 年龄
if age:
user_information.age = age
# 性别 1 - 男 2 - 女
if sex:
user_information.sex = sex
# 用户名
if name:
user = User.query.filter_by(name=name).filter(User.id != user_id).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="用户名已经存在")
user_information.name = name
db.session.commit()
except Exception as e:
db.session.rollback() # 回滚数据库
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
return jsonify(code=RET.OK, msg="修改成功")
# 企业的收藏加个下拉列表来判断来自哪个表--是全国企业还是山西企业。返回值里面要带有status还未添加
# 查看收藏----页数，分类
@api_user.route("/collect", methods=["POST"])
@login_required
def collect_com():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.get_json()
page = req_dict.get("page")
per_page = req_dict.get("per_page")
classify = req_dict.get("classify")
choice = req_dict.get("choice")
if not page:
page = 1
if not per_page:
per_page = 10
if not all([classify, choice]):
return jsonify(code=RET.PARAMERR, msg="数据不全")
# 判断是企业还是行业关注，企业1，行业0
if classify == 1:
company = []
try:
user = User.query.get(user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
if choice == "2":
try:
maxnum = len(user.enterprise)
company_list = user.enterprise[(page - 1) * per_page:page * per_page]
for i in company_list:
create_time = UserEnterprise.query.filter_by(enterprise_id=i.id, user_id=user_id).first()
company.append({
"id": i.id,
"company_name": i.company_name,
"create_time": create_time.create_time.strftime('%Y-%m-%d %H:%M:%S'),
"build_date": i.build_date.strftime("%Y-%m-%d") if i.build_date else "-"
})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
data = {
"ob_list": company,
"maxnum": maxnum
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
else:
maxnum = len(user.company)
company_list = user.company[(page - 1) * per_page:page * per_page]
try:
for i in company_list:
create_time = UserCompany.query.filter_by(company_id=i.id, user_id=user_id).first()
company.append({
"id": i.id,
"company_name": i.company_name,
"create_time": create_time.create_time.strftime('%Y-%m-%d %H:%M:%S'),
"build_date": i.build_date.strftime("%Y-%m-%d") if i.build_date else "-"
})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
data = {
"ob_list": company,
"maxnum": maxnum
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
# 行业
try:
user = User.query.get(user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
maxnum = len(user.industry)
industry = []
industry_list = user.industry[(page - 1) * per_page:page * per_page]
for i in industry_list:
# 查询关注时间
try:
indu = UserIndustry.query.filter_by(industry_id=i.id, user_id=user_id).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# count = Company.query.filter_by(company_industry = i.name)
industry.append({
"id": i.id,
"industry_name": i.name,
"create_time": indu.create_time.strftime("%Y-%m-%d"),
"count": i.entities if i.entities else 0
})
data = {
"ob_list": industry,
"maxnum": maxnum
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
# 取消收藏
@api_user.route("/delete", methods=["POST"])
@login_required
def delete():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.get_json()
id = req_dict.get("id")
classify = req_dict.get("classify")
choice = req_dict.get("choice")
print(id, classify, choice)
if not all([id, classify, choice]):
return jsonify(code=RET.PARAMERR, msg="数据不全")
# id = g.id
if classify == 1:
if choice == "2":
# 删除全国数据
# pass
try:
company_user = UserEnterprise.query.filter_by(enterprise_id=id, user_id=user_id).first()
db.session.delete(company_user)
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
else:
try:
company_user = UserCompany.query.filter_by(company_id=id, user_id=user_id).first()
db.session.delete(company_user)
db.session.commit()
return jsonify(code=RET.OK, msg="删除成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 删除企业数据
try:
industry_user = UserIndustry.query.filter_by(industry_id=id, user_id=user_id).first()
db.session.delete(industry_user)
db.session.commit()
return jsonify(code=RET.OK, msg="取关成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
apps/util.py 0 → 100644
from werkzeug.routing import BaseConverter
from apps.utils.response_code import RET
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from itsdangerous import SignatureExpired, BadSignature
from flask import request, jsonify, current_app
from config import Config
from apps.models import User, Bstage
import functools
# from flask_httpauth import HTTPBasicAuth
#
# auth = HTTPBasicAuth
class RegexConverter(BaseConverter):
def __init__(self, url_map, regex):
super(RegexConverter, self).__init__(url_map)
self.regex = regex
def create_token(api_user):
'''
生成token
:param api_user:用户id
:return: token
'''
# 第一个参数是内部的私钥,第二个参数是有效期(秒)
s = Serializer(current_app.config["SECRET_KEY"], expires_in=Config.TOKEN_EXPIRATION)
# 接收用户id转换与编码
token = s.dumps({"id": api_user,"type":"登录验证"}).decode("ascii")
return token
def verify_token(token):
'''
校验token
:param token:
:return: 用户信息 or None
'''
s = Serializer(current_app.config["SECRET_KEY"])
# try:
# s = s.loads(token)
# except BadSignature:
# raise AuthFailed(msg="token is invalid", error_code=1004)
# except SignatureExpired:
# raise AuthFailed(msg="token is expired", error_code=1004)
try:
data = s.loads(token)
except SignatureExpired: # 签名错误，签名被修改
print("签名错误")
return None # valid token,but expired
except BadSignature: # 签名已过期
print("签名过期")
return None # invalid token
# 拿到转换后的数据，根据模型类去数据库查询用户信息
user = User.query.get(data["id"])
return user
# 后台验证
def verify_btoken(token):
'''
校验token
:param token:
:return: 用户信息 or None
'''
s = Serializer(current_app.config["SECRET_KEY"])
try:
# 转换为字典
data = s.loads(token)
except Exception:
return None
# 拿到转换后的数据，根据模型类去数据库查询用户信息
user = Bstage.query.get(data["id"])
return user
def login_required(view_func):
@functools.wraps(view_func)
def verify_token(*args, **kwargs):
try:
# 在请求头上拿到token
token = request.headers["token"]
except Exception:
# 没接收的到token,给前端抛出错误
return jsonify(code=RET.NODATA, msg='缺少参数token')
s = Serializer(current_app.config["SECRET_KEY"])
try:
s.loads(token)
except Exception:
return jsonify(code=RET.SESSIONERR, msg="未登录，或者登录已过期")
return view_func(*args, **kwargs)
return verify_token
apps/utils/commons.py 0 → 100644
from werkzeug.routing import BaseConverter
from apps.utils.response_code import RET
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from flask import request, jsonify, current_app
from config import Config
import functools
# 1.自定义类,继承自BaseConverter
class RegexConverter(BaseConverter):
# 2.编写初始化方法, init方法, 接收两个参数, url_map, regex, 并初始化父类空间和子类空间
def __init__(self, url_map, regex):
super(RegexConverter, self).__init__(url_map)
self.regex = regex
apps/utils/encrypt_decrypt/aes_cbc.py 0 → 100644
# import json
import base64
from Crypto.Cipher import AES
BS = 16 # 与key长度一致
# pad = lambda s: s + (BS - len(s.encode("utf-8")) % BS) * chr(BS - len(s.encode("utf-8")) % BS)
def pad(s):
return s + (BS - len(s.encode("utf-8")) % BS) * chr(BS - len(s.encode("utf-8")) % BS)
# unpad = lambda s: s[0:-ord(s[-1:])]
def unpad(s):
return s[0:-ord(s[-1:])]
def encrypt(content):
key = iv = "qwertyuiopasdfgh".encode("utf-8")
mode = AES.MODE_CBC
cipher = AES.new(key, mode, iv)
encrypt_bytes = cipher.encrypt(pad(content).encode("utf-8"))
result = base64.b64encode(encrypt_bytes).decode("utf-8")
return result
def decrypt(content):
key = iv = "qwertyuiopasdfgh".encode("utf-8")
mode = AES.MODE_CBC
cipher = AES.new(key, mode, iv)
encrypt_bytes = base64.b64decode(content)
# 解密
decrypt_bytes = cipher.decrypt(encrypt_bytes)
result = decrypt_bytes.decode("utf-8")
result = unpad(result)
return result
if __name__ == '__main__':
data = {'id': 85, 'surface': 'https://store.industrychain.online/shangpin_img/半导体.png', 'title': '半导体产业创新企业榜单',
'pub_date': '2021-07-19', 'sales': 1, 'price': 12.9, 'type': '榜单'}
# print(encrypt(json.dumps(data)))
print(encrypt("qwe"))
# print(decrypt(res))
# print(json.loads(decrypt(res)))
apps/utils/forms.py 0 → 100644
from wtforms import Form, FileField, StringField
from wtforms.validators import InputRequired
from flask_wtf.file import FileRequired, FileAllowed
# 验证图片文件
class UploadFormImage(Form):
image = FileField(validators=[FileRequired(), # FileRequired必须上传
FileAllowed(['jpg', 'png', 'gif', "jpeg"], message='文件格式错误,或文件名携带中文')
# FileAllowed:必须为指定的格式的文件
])
id = StringField(validators=[InputRequired()])
# 验证其他文件
class UploadFormFile(Form):
file = FileField(validators=[FileRequired(), # FileRequired必须上传
FileAllowed(['xls', 'xlsx'],
message='文件格式错误')
])
id = StringField(validators=[InputRequired()])
# 验证其他文件
class UploadFormDoc(Form):
file = FileField(validators=[FileRequired(), # FileRequired必须上传
FileAllowed(['xls', 'xlsx', 'pdf', 'ppt', 'pptx', "doc", "docx", "zip", "rar"],
message='文件格式错误')
])
id = StringField(validators=[InputRequired()])
size = StringField(validators=[InputRequired()])
apps/utils/json/city.json 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
apps/utils/json/city_原始.json 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
apps/utils/json/ty_rsa 0 → 100644
-----BEGIN PRIVATE KEY-----
MIICWgIBAAKBgQCbhcu70wIoXnVhhGimrJWaQ1y5M3F8oDM6maLSjiVmaN0Kc7AN
EFF+jOtiN3C0xNxyaAINxi0J53Az1ezYIsa83vfZT0J0W53LtDXmfJQkuTFF333Z
PFZheRQqDrH08mDEL2S/aLgll1GyrKYP8IEO39xvkEuoAHK1Qcsjb4VQiQIDAQAB
An8m4UwNqLLhZLvzpSaEhKDh7/U+V54HigVEoSQTf3XaJF0eP83DdlDpUlGGPFXw
20ZBU78vsluQHkvuqYyMfCUyrrTgZYCCUgguWt0nbdc8YcFKiXn2P8ki5pEzt4mV
UwGoWIB7WQ4wVscghwE+6uFhi+0IzW3C2eigg3jqDIUBAkEAwCuda9LRlZIn2PDQ
CvEB574BNcU3vvaRemK5WnZ/Iep23ENf0nyE2CLgELxcu4aY6vZSNvrUD2T9+Gub
PYd8HwJBAM8t/3nsA3vhok8XDUWoee18k36mopZiRT/hB5FGQl4aX+p+EDAVeytQ
9WNim4R5RD+rym92ktJfzZj50hxBnlcCQCPZfxqYT6T5iRl9gzInV9WlqpAfZJDp
aqZMOIvZw0nOdbINl5iqxhWUG/zDRwFs0KY0oY3EKT9d9cscN++4kL0CQQC33Ll6
SSL6YM67Y9jKde7m/QSkhFuMHGAahalCmtixTLTMlN3m3ll1op5zegJMOZaA7wNz
kgZQnucGGMcHfpB3AkAr249EUriJXa8MfzolpCq2aWD974vFOINgz7GMj+B/a0fO
jzQ9j/fWp7330spy1lllWuVSYyA2OuhiH7HZHSSg
-----END PRIVATE KEY-----
apps/utils/json/type.json 0 → 100644
[
{
"id": 1,
"name": "\u9ad8\u7aef\u88c5\u5907",
"child": [
{
"id": 6,
"name": "\u65b0\u80fd\u6e90\u6c7d\u8f66"
},
{
"id": 7,
"name": "\u667a\u80fd\u7164\u673a"
},
{
"id": 8,
"name": "\u8f68\u9053\u4ea4\u901a"
},
{
"id": 9,
"name": "\u6570\u63a7\u673a\u5e8a"
}
]
},
{
"id": 2,
"name": "\u65b0\u6750\u6599",
"child": [
{
"id": 10,
"name": "\u7164\u57fa\u78b3\u6750\u6599"
},
{
"id": 11,
"name": "\u7164\u5316\u5de5\u6750\u6599"
},
{
"id": 12,
"name": "\u94a2\u94c1\u65b0\u6750\u6599"
},
{
"id": 13,
"name": "\u8010\u706b\u65b0\u6750\u6599"
}
]
},
{
"id": 3,
"name": "\u65b0\u4e00\u4ee3\u4fe1\u606f\u6280\u672f",
"child": [
{
"id": 14,
"name": "\u4fe1\u606f\u6280\u672f\u5e94\u7528\u521b\u65b0"
},
{
"id": 15,
"name": "\u5927\u6570\u636e"
},
{
"id": 16,
"name": "\u7269\u8054\u7f51"
},
{
"id": 17,
"name": "\u4eba\u5de5\u667a\u80fd"
},
{
"id": 18,
"name": "\u8f6f\u4ef6\u5f00\u53d1"
}
]
},
{
"id": 4,
"name": "\u7eff\u8272\u80fd\u6e90",
"child": [
{
"id": 19,
"name": "\u6e05\u6d01\u7164\u6750\u6599"
},
{
"id": 20,
"name": "\u667a\u80fd\u7535\u7f51"
},
{
"id": 21,
"name": "\u6c22\u80fd"
}
]
},
{
"id": 5,
"name": "\u751f\u7269\u533b\u836f",
"child": [
{
"id": 22,
"name": "\u5316\u5b66\u5236\u836f"
},
{
"id": 23,
"name": "\u751f\u7269\u5236\u836f"
},
{
"id": 24,
"name": "\u5065\u5eb7\u670d\u52a1"
}
]
}
]
apps/utils/neo4j_conn.py 0 → 100644
from py2neo import Graph
def conn_neo4j():
graph = Graph("http://localhost:7474", username="neo4j", password="century-english-almanac-havana-golf-9040")
# graph = Graph("http://localhost:7474", username="neo4j", password="123456")
return graph
# 'match (n) -[r:`下位产品`]->(m) WHERE n.name=\\'网络安全\\' return n.name,r.type,m.name'
# s = "match (n) -[r:`下位产品`]->(m) WHERE n.name='轨道交通' return n.name,r.type,m.name"
# #
# graph = conn_neo4j()
# res = graph.run(s).data()
# print(res)
def neo4j_dict():
ptp = {"轨道交通": "轨道交通",
"新能源汽车": "新能源汽车",
"智能煤机": "智能煤机",
"数控机床及机器人": "工业机器人",
"通用航空": "通用航空",
"智能电网": "智能电网",
"氢能": "氢能",
"碳基新材料": "碳基新材料",
"特种金属新材料": "特种金属材料",
"化工新材料": "新型化工材料",
"生物基新材料": "生物基新材料",
"信息技术应用创新": "信息创新技术",
"网络安全": "网络安全",
"云计算": "云计算",
"大数据及人工智能": "大数据及人工智能",
"物联网": "物联网",
"康养产业": "康养服务",
"生物制药": "生物医药",
"现代物流": "现代物流",
"现代金融": "现代金融",
"半导体及光电子": "新一代半导体",
"节能环保": "节能环保装备"
}
return ptp
apps/utils/read_json.py 0 → 100644
import json, os, re
def open_type():
upload_path = os.path.dirname(os.path.dirname(__file__)) + "/utils/json/type.json"
with open(upload_path, encoding="utf-8") as f:
data = json.load(f)
return data
# print(open_type())
# def cut_text(num, lenth):
# t = str(num)[::-1]
# t_Arr = re.findall('.{' + str(lenth) + '}', t)
# t_Arr.append(t[(len(t_Arr) * lenth):])
# s_str = ",".join(t_Arr)[::-1]
# if s_str[0] == ",":
# s_str = s_str[1:]
# return s_str
# def openDists():
# upload_path = os.path.dirname(os.path.dirname(__file__)) + "/conf/json/city.json"
# with open(upload_path, encoding="utf-8") as f:
# data = json.load(f)
#
# return data
# print(os.path.dirname(os.path.dirname(__file__))+ "/utils/json/type.json")
# def open_tt():
# upload_path = os.path.dirname(os.path.dirname(__file__)) + "/conf/json/tt.json"
# with open(upload_path, encoding="utf-8") as f:
# data = json.load(f)
#
# return data
apps/utils/response_code.py 0 → 100644
# 记录状态码
class RET:
OK = "0"
DBERR = "4001"
NODATA = "4002"
DATAEXIST = "4003"
DATAERR = "4004"
SESSIONERR = "4101"
LOGINERR = "4102"
PARAMERR = "4103"
USERERR = "4104"
ROLEERR = "4105"
PWDERR = "4106"
REQERR = "4201"
IPERR = "4202"
THIRDERR = "4301"
IOERR = "4302"
SERVERERR = "4500"
UNKOWNERR = "4501"
MOBILEERR = "4900"
LOCKTIME = "4005"
error_map = {
RET.OK: "成功",
RET.DBERR: "数据库查询错误",
RET.NODATA: "无数据",
RET.DATAEXIST: "数据已存在",
RET.DATAERR: "数据错误",
RET.SESSIONERR: "用户未登录",
RET.LOGINERR: "用户登录失败",
RET.PARAMERR: "参数错误",
RET.USERERR: "用户不存在或未激活",
RET.ROLEERR: "用户身份错误",
RET.PWDERR: "密码错误",
RET.REQERR: "非法请求或请求次数受限",
RET.IPERR: "IP受限",
RET.THIRDERR: "第三方系统错误",
RET.IOERR: "文件读写错误",
RET.SERVERERR: "内部错误",
RET.UNKOWNERR: "未知错误",
RET.MOBILEERR: "手机格式错误",
}
apps/utils/send_phone_info.py 0 → 100644
import json
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import CommonRequest
def send_code(phone, c_num):
client = AcsClient('LTAI4Fkgi7DUf6jCVW3KNGwT', 'ynr6TWWNOnpALn3YUICUaXwpp9w4er', 'cn-hangzhou')
request = CommonRequest()
request.set_accept_format('json')
request.set_domain('dysmsapi.aliyuncs.com')
request.set_method('POST')
request.set_protocol_type('https') # https | http
request.set_version('2017-05-25')
request.set_action_name('SendSms')
request.add_query_param('RegionId', "cn-hangzhou")
request.add_query_param('PhoneNumbers', phone)
# 签名
request.add_query_param('SignName', "中研认知产业链在线")
# 模板
request.add_query_param('TemplateCode', "SMS_186575190")
request.add_query_param('TemplateParam', "{\"code\":\"" + c_num + "\"}")
response = client.do_action(request)
el = eval(str(response, encoding='utf-8'))
return el
def send_code_wang(phone, c_num):
client = AcsClient('LTAI4Fkgi7DUf6jCVW3KNGwT', 'ynr6TWWNOnpALn3YUICUaXwpp9w4er', 'cn-hangzhou')
request = CommonRequest()
request.set_accept_format('json')
request.set_domain('dysmsapi.aliyuncs.com')
request.set_method('POST')
request.set_protocol_type('https') # https | http
request.set_version('2017-05-25')
request.set_action_name('SendSms')
request.add_query_param('RegionId', "cn-hangzhou")
request.add_query_param('PhoneNumbers', phone)
# 签名
request.add_query_param('SignName', "太原市招商图谱平台")
# 模板
request.add_query_param('TemplateCode', "SMS_187755198")
request.add_query_param('TemplateParam', "{\"code\":\"" + c_num + "\"}")
response = client.do_action(request)
el = eval(str(response, encoding='utf-8'))
return el
def send_code_new(phone, c_num):
client = AcsClient('LTAI4Fkgi7DUf6jCVW3KNGwT', 'ynr6TWWNOnpALn3YUICUaXwpp9w4er', 'cn-hangzhou')
request = CommonRequest()
request.set_accept_format('json')
request.set_domain('dysmsapi.aliyuncs.com')
request.set_method('POST')
request.set_protocol_type('https') # https | http
request.set_version('2017-05-25')
request.set_action_name('SendSms')
request.add_query_param('RegionId', "cn-hangzhou")
request.add_query_param('PhoneNumbers', phone)
# 签名
request.add_query_param('SignName', "中研认知产业链在线")
# 模板
request.add_query_param('TemplateCode', "SMS_187752221")
request.add_query_param('TemplateParam', "{\"code\":\"" + c_num + "\"}")
response = client.do_action(request)
el = eval(str(response, encoding='utf-8'))
return el
def code_new(phone, c_num):
client = AcsClient('LTAI4Fkgi7DUf6jCVW3KNGwT', 'ynr6TWWNOnpALn3YUICUaXwpp9w4er', 'cn-hangzhou')
request = CommonRequest()
request.set_accept_format('json')
request.set_domain('dysmsapi.aliyuncs.com')
request.set_method('POST')
request.set_protocol_type('https') # https | http
request.set_version('2017-05-25')
request.set_action_name('SendSms')
request.add_query_param('RegionId', "cn-hangzhou")
request.add_query_param('PhoneNumbers', phone)
# 签名
request.add_query_param('SignName', "中研认知产业链在线")
# 模板
request.add_query_param('TemplateCode', "SMS_187752221")
request.add_query_param('TemplateParam', "{\"code\":\"" + c_num + "\"}")
response = client.do_action(request)
el = eval(str(response, encoding='utf-8'))
return el
# print(send_code('15769202654', '9999'))
apps/utils/sign_rsassa_plcs1_V1_5.py 0 → 100644
import os
import json
import base64
import requests
import hashlib
from Crypto.Hash import SHA256
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5 as Signature_pkcs1_v1_5
# 签名类
class Signature:
'''
爱城市网扫码登录
https://open.icity24.cn/
'''
def __init__(self, params):
# self.url = "https://auth.icity24.cn/icity/auth2.0/token"
self.params = params
self.privetkey_file_path = os.path.dirname(os.path.dirname(__file__)) + "/utils/json/ty_rsa"
self.privetkey = self.read_privet_key()
self.unsign_data = self.generate_sign(self.params)
# 读取私钥
def read_privet_key(self):
with open(self.privetkey_file_path, mode="r", encoding="utf-8") as f:
privetkey = "".join(f.readlines()[1:-1])
privetkey = privetkey.encode(encoding='utf-8')
return privetkey
# HASH-sha256
def generate_sign(self, param):
'''生成hash'''
# 按ASCII拼接字符串
stringA = "&".join([f"{k}={param[k]}" for k in sorted(param)])
# SHA256加密
hash_sha256 = hashlib.sha256(stringA.encode('utf8')).hexdigest()
return hash_sha256
# 生成签名
def gen_sign(self, secret=None):
"""
生成签名：是直接读取私钥的方式和未加签的数据
:return: 签名数据
"""
rsaKey = RSA.importKey(base64.b64decode(self.privetkey), passphrase=secret)
signer = Signature_pkcs1_v1_5.new(rsaKey)
digest = SHA256.new()
digest.update(self.unsign_data.encode('utf8'))
sign = signer.sign(digest)
signature = base64.b64encode(sign)
return signature.decode()
'''1、获取token'''
appid = "fea79d4c-9906-408c-86a5-8a092fda49b3"
code = "c417598b-5892-4217-81be-c3b6080e9fa1"
# code换取token
params = {
'appid': appid, # 爱城市网appID
'code': code, # 授权成功后产生的code
'grant_type': "authorization_code"
}
# 获取签名sign
s = Signature(params)
sign_value = s.gen_sign()
params["sign"] = sign_value
# 认证获取token
resp = requests.post(url="https://auth.icity24.cn/icity/auth2.0/token", data=params)
resp = json.loads(resp.text)
token = resp["token"]
'''2、token获取baseinfo'''
params = {
'appid': appid, # 爱城市网appID
'auth_token': token, # token
}
# 获取新签名sign
s = Signature(params)
sign_value = s.gen_sign()
params["sign"] = sign_value
# 获取基本信息
user_info = requests.post(url="https://auth.icity24.cn/icity/auth2.0/get_base_info", data=params)
user_info = json.loads(user_info.text)
mobile_phon = user_info["mobile_phon"] # 手机号
apps/utils/vxconfig.py 0 → 100644
class WxConfig(object):
_wx_conf = {
'AppID': 'wxb44559f2cbe1efcf',
'AppSecret': 'b81f33dfc82e40122dfe4ea6269dd46a'
}
@classmethod
def get_wx_app_id(cls):
return cls._wx_conf.get('AppID')
@classmethod
def get_wx_app_secret(cls):
return cls._wx_conf.get('AppSecret')
apps/view_360/__init__.py 0 → 100644
from flask import Blueprint
# 创建蓝图对象
api_portraits = Blueprint("api_portraits", __name__)
from . import view
'''360企业画像'''
apps/view_360/view.py 0 → 100644
import os
import json
from elasticsearch import Elasticsearch
from flask import request, jsonify, current_app
from apps.models import *
from apps.view_360 import api_portraits
from apps.util import login_required, verify_token
from apps.utils.response_code import RET
from apps import redis_store
def body_qualificat(s, j):
body = {
"query": {
"bool": {
"must": {"match": {"{}": "{}".format(s, j)}}
}
}
}
return body
def body_type(s):
body = {
"query": {
"bool": {
"must": {"match": {"entypeid": "{}".format(s)}}
}
}
}
return body
def create_body(page, page_size, args_query, args_term):
body = {
"query": {
"bool": {
"filter": {
"range": {
"build_date": {
}
}
},
"must": [
{"multi_match": {
"query": "{}".format(args_query["query"]),
"type": "best_fields",
"fields": [
"product^1.0",
"company_name^1.0",
"industry^1.0"
],
"tie_breaker": 0.3
}
},
]
}
},
"from": page,
"size": page_size,
"sort": [],
"aggs": {},
"_source": [
# 'all_info',
'industry', 'build_date', 'register_money_nums', 'product',
'company_name', "mysql_id"
],
"highlight": {
"fields": {
"product": {"type": "plain"},
"company_name": {"type": "plain"},
"industry": {"type": "plain"}
}
}
}
for k, v in args_term.items():
body["query"]["bool"]["must"].append({"term": {"{}".format(k): "{}".format(v)}})
return body
# 360企业画像两个静态表（如果前端页面进行删除，此接口也一并删除）
@api_portraits.route("/table", methods=["GET"])
def table():
try:
name_query = "static_360"
if redis_store.get(name_query) is not None:
data = json.loads(redis_store.get(name_query))
return jsonify(code=RET.OK, msg="获取成功", data=data)
company = Enterprise.query.filter_by()
grdz = company.filter_by(entypeid=1).count()
gfyx = company.filter_by(entypeid=2).count()
hhqy = company.filter_by(entypeid=3).count()
jtsy = company.filter_by(entypeid=4).count()
gyqy = company.filter_by(entypeid=5).count()
yxzr = company.filter_by(entypeid=6).count()
wstz = company.filter_by(entypeid=7).count()
new_dic = [grdz, yxzr, gfyx, jtsy, hhqy, gyqy, wstz]
gxjs = company.filter_by(high_new="1").count()
kjzx = company.filter_by(tbe="1").count()
ssqy = company.filter_by(quoted_company="1").count()
djs = company.filter_by(unicorn="1").count()
dlqy = company.filter_by(dengl="1").count()
quality_list = [gxjs, kjzx, ssqy, djs, dlqy]
data = {
"type": new_dic,
"quality": quality_list
}
# redis缓存
redis_store.set(name_query, json.dumps(data))
redis_store.expire(name_query, 30 * 24 * 3600)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.OK, msg="数据库错误")
return jsonify(code=RET.OK, msg="查询成功", data=data)
# 360企业画像两个静态表(参数数据)(如果前端页面进行删除，此接口也一并删除)
@api_portraits.route("/doubleTable", methods=["POST"])
def double_table():
# 获取参数
req_dict = request.get_json()
area = req_dict.get("area") # 省市区参数
province = ""
city = ""
district = ""
if area[0]:
province = area[0]
if area[1]:
city = area[1]
if area[2]:
district = area[2]
if not all([area]):
return jsonify(code=RET.NODATA, msg="参数缺失")
try:
name_query = "static_360" + province + city + district
if redis_store.get(name_query) is not None:
data = json.loads(redis_store.get(name_query))
return jsonify(code=RET.OK, msg="获取成功", data=data)
company = Enterprise.query.filter_by()
if province:
company = company.filter_by(province=province)
if city:
company = company.filter_by(city=city)
if district:
company = company.filter_by(district=district)
grdz = company.filter_by(entypeid=1).count()
gfyx = company.filter_by(entypeid=2).count()
hhqy = company.filter_by(entypeid=3).count()
jtsy = company.filter_by(entypeid=4).count()
gyqy = company.filter_by(entypeid=5).count()
yxzr = company.filter_by(entypeid=6).count()
wstz = company.filter_by(entypeid=7).count()
new_dic = [grdz, yxzr, gfyx, jtsy, hhqy, gyqy, wstz]
gxjs = company.filter_by(high_new="1").count()
kjzx = company.filter_by(tbe="1").count()
ssqy = company.filter_by(quoted_company="1").count()
djs = company.filter_by(unicorn="1").count()
dlqy = company.filter_by(dengl="1").count()
quality_list = [gxjs, kjzx, ssqy, djs, dlqy]
data = {
"type": new_dic,
"quality": quality_list
}
# redis缓存
redis_store.set(name_query, json.dumps(data))
redis_store.expire(name_query, 29 * 24 * 3600)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.OK, msg="数据库错误")
return jsonify(code=RET.OK, msg="查询成功", data=data)
def openDists():
upload_path = os.path.dirname(os.path.dirname(__file__)) + "/utils/json/city.json"
with open(upload_path, encoding="utf-8") as f:
data = json.load(f)
return data
# 地域层级数据分级获取
@api_portraits.route('/getRegion', methods=['GET'])
def getRegion():
try:
data = openDists()
if len(data) > 0:
return jsonify(code=200, msg="查找成功", data=data)
else:
return jsonify(code=201, msg="暂时没有数据")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="查找错误")
@api_portraits.route('/field', methods=['GET'])
# @login_required
def field():
'''
全国企业条件选择导航获取
:return:
'''
try:
property = Property.query.filter_by(statu=1)
typy = property.filter_by(sid=1, statu=1).all()
qualificat = property.filter_by(sid=2, statu=1).all()
quoted = property.filter_by(sid=3, statu=1).all()
financ = property.filter_by(sid=4, statu=1).all()
# options: [{ value: "选项1", label: "无数据" },{ value: "选项2", label: "3333" }],
data = {"entype": [{"label": i.name, "value": i.nid} for i in typy],
"qualificat": [{"label": i.name, "value": i.nid} for i in qualificat],
"quoted": [{"label": i.name, "value": i.nid} for i in quoted],
"financ": [{"label": i.name, "value": i.nid} for i in financ],
"buildate": [{"label": "1-3年", "value": 1}, {"label": "3-5年", "value": 2},
{"label": "5-8年", "value": 3}, {"label": "8-10年", "value": 4},
{"label": "10-15年", "value": 5}, {"label": "15年以上", "value": 6}],
"capital": [{"label": "100万以内", "value": 1}, {"label": "100万-500万", "value": 2},
{"label": "500万-1000万", "value": 3}, {"label": "1000万-5000万", "value": 4},
{"label": "1000万-1亿", "value": 5}, {"label": "1亿以上", "value": 6}]
}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", options=data)
# 搜索接口
@api_portraits.route("/search", methods=["POST"])
@login_required
def search():
# 获取用户信息
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
# user_id = 5
# 参数获取
req_dict = request.get_json()
company = req_dict.get("company") # 搜索企业名称
entypeid = req_dict.get("entypeid") # 企业类型
qualificat = req_dict.get("qualificat") # 资质
capital_id = req_dict.get("capital_id") # 资本
public_id = req_dict.get("public_id") # 上市状态
area = req_dict.get("area") # 地区条件获取
if area == []:
area = ["", "", ""]
province = area[0]
city = area[1]
district = area[2]
yearid = req_dict.get("yearid") # 成立时间
financ_id = req_dict.get("financ_id") # 融资轮次
page = req_dict.get("page") # 页码
per_page = int(req_dict.get("per_page")) # 每页大小
# 页数
if not page:
page = 1
page = int(page)
page = (page - 1) * per_page
args_query = dict() # 查询字段
args_term = dict() # 条件字典
args_query["query"] = "公司"
# 搜索框
if company:
args_query["query"] = company
# 添加搜索历史
try:
user = User.query.get(user_id)
b = []
if user.searchlist:
for j in user.searchlist:
b.append(j.history)
if company in b:
user.searchlist.remove(user.searchlist[b.index(company)])
if len(b) > 5:
user.searchlist.remove(user.searchlist[0])
search = SearchList(history=company)
db.session.add(search)
user.searchlist.append(search)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 公司类型
if entypeid:
args_term['entypeid'] = entypeid
# 注册资本
if capital_id:
args_term['capital_id'] = capital_id
# 上市状态
if public_id:
args_term['public_id'] = public_id
# 省
if province:
args_term['province'] = province
# 市
if city:
args_term['city'] = city
# 区
if district:
args_term['district'] = district
# 公司资质
if qualificat:
if qualificat == 1:
args_term['high_new'] = 1
if qualificat == 2:
args_term['tbe'] = 1
if qualificat == 3:
args_term['quoted_company'] = 1
if qualificat == 4:
args_term['isfive'] = 1
if qualificat == 5:
args_term['unicorn'] = 1
if qualificat == 6:
args_term['dengl'] = 1
# 成立时间
if yearid:
args_term['yearid'] = yearid
# 融资轮次
if financ_id:
args_term['financ_id'] = financ_id
body = create_body(page, per_page, args_query, args_term)
if not company:
del body["query"]["bool"]["must"][0]
try:
es = Elasticsearch([{'host': 'localhost', 'port': 9200}])
# data = es.search(index="ty_360", body=body)
data = es.search(index="ty_enterprise", body=body)
data_list = []
# 数据的列表添加进去
for i in data["hits"]['hits']:
if company:
# 判断高亮，然后添加
data_list.append({
"company": i["highlight"]["company_name"][0] if "company_name" in i["highlight"] else i["_source"][
"company_name"],
"product": i["highlight"]["product"][0] if "product" in i["highlight"] else i["_source"]["product"],
"industry": i["highlight"]["industry"][0] if "industry" in i["highlight"] else i["_source"][
"industry"],
"money": "{}万元".format(i["_source"]["register_money_nums"]),
"createtime": i["_source"]["build_date"],
"id": i["_source"]["mysql_id"],
"choice": 2
})
else:
data_list.append({
"company": i["_source"]["company_name"],
"product": i["_source"]["product"],
"industry": i["_source"]["industry"],
"money": "{}万元".format(i["_source"]["register_money_nums"]),
"createtime": i["_source"]["build_date"],
"id": i["_source"]["mysql_id"],
"choice": 2,
})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="es数据库错误")
data = {
"data": data_list
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
# 搜索历史接口
@api_portraits.route("/searchList", methods=["GET"])
@login_required
def search_list():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
# user_id = 119
try:
user = User.query.get(user_id)
history = [(i.history, i.id) for i in user.searchlist]
# print(history)
# print(sorted(history, key=lambda x: x[1], reverse=True))
# data = {
# "search": [i.history for i in user.searchlist]
# }
data = {"search": [i[0] for i in sorted(history, key=lambda x: x[1], reverse=True)]}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 全国企业信息详情
@api_portraits.route('/detail', methods=['POST'])
@login_required
def enter_detail():
'''
企业信息详情
:return:
'''
# 获取用户id
token = request.headers["token"]
user = verify_token(token)
user_id = user.id # 用户id
req_dict = request.get_json()
_id = req_dict.get("id") # 企业id
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
company = Enterprise.query.get(_id)
user = User.query.get(user_id) # 获取关注列表
if user:
enters_ids = [coms.id for coms in user.enterprise]
else:
enters_ids = []
if company:
data = {"id": company.id,
"company_name": company.company_name,
"telephone": company.telephone if company.telephone else "-",
"web_site": company.web_site if company.web_site else "-",
"email": company.email if company.email else "-",
"address": company.address if company.address else "-",
"jwd": {"lng": company.lng if company.lng else "-",
"lat": company.lat if company.lat else "-"},
"company_info": company.company_info if company.company_info else "-",
"isfive": "500强企业" if company.isfive == "1" else "", # 500强
"quoted_company": "上市企业" if company.quoted_company == "1" else "", # 上市企业
"high_new": "高新技术企业" if company.high_new == "1" else "",
"tbe": "科技型中小企业" if company.tbe == "1" else "", # 科技型中小企业
"unicorn": "独角兽企业" if company.unicorn == "1" else "", # 独角兽企业
"dengl": "瞪羚企业" if company.dengl == "1" else "", # 瞪羚企业
"legal": company.legal if company.legal else "-",
"status": company.status if company.status else "-",
"build_date": str(company.build_date)[:10] if company.build_date else "-",
"capital": company.capital if company.capital else "-",
"social_code": company.social_code if company.social_code else "-",
"taking": company.takingn if company.takingn else "-",
"bao": company.bao_num if company.bao_num else "-",
"entype": company.entype if company.entype else "-",
"industry": company.company_industry if company.company_industry else "-",
"scope": company.business_scope if company.business_scope else "-",
"collect": "1" if company.id in enters_ids else "2", # 关注状态码1关注，2未关注
"choice": "2" # 1太原企业，2全国企业
}
else:
return jsonify(code=RET.NODATA, msg="查无数据")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
apps/view_attract/__init__.py 0 → 100644
from flask import Blueprint
# 招商驾驶舱
api_attract = Blueprint("api_attract", __name__)
from . import view # 招商驾驶舱数据
from . import view_changedata # 修改招商驾驶舱数据（区域宏观经济、作战图、项目产业分布图）
apps/view_attract/view.py 0 → 100644
import json
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkvod.request.v20170321.GetPlayInfoRequest import GetPlayInfoRequest
from flask import request, jsonify, session, current_app
from sqlalchemy import func, desc, or_
from apps.models import *
from apps.view_attract import api_attract
from apps.utils.response_code import RET
from apps import db, constants, redis_store
# 获取左上角经济指标数据
def get_jjzb(district):
'''经济指标数据'''
years = [2021] # 指定数据的年份，与数据库中数据对齐
try:
if not district or district == '晋城市':
datas = City.query.filter_by(area='晋城市').filter(City.year.in_(years)).all()
else:
datas = City.query.filter_by(area=district).filter(City.year.in_(years)).all()
df = [{"list": [{"nums": '%.2f亿元' % (data.GDP / 10000) if data.GDP else "-亿元", "name": "地区生产总值"},
{"nums": '%.2f' % data.addscale + "%" if data.addscale else "-%", "name": "规上工业增加值增速"},
{"nums": '%.2f亿元' % (data.investment / 10000) if data.investment else "-亿元",
"name": "固定资产投资"},
{"nums": '%.2f亿元' % (data.retail / 10000) if data.retail else "-亿元", "name": "社会消费品零售额"},
{"nums": '%.2f亿元' % (data.in_out / 10000) if data.in_out else "-亿元", "name": "进出口总额"},
{"nums": '%.2f亿元' % (data.public / 10000) if data.public else "-亿元", "name": "一般公共预算支出"},
{"nums": '%.2f元' % data.people_out if data.people_out else "-元", "name": "居民人均可支配收入"},
{"nums": '%.2f' % data.people_per if data.people_per else "-", "name": "居民消费价格指数"}],
"desc": data.question if data.question else ""} for data in datas]
# return jsonify(code=RET.OK, msg="查找成功", data=df)
return df
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 左上角企业数量各资质统计、左上角获取经济指标数据、产业机构分布饼状图数据统计
@api_attract.route("/menu", methods=["POST"])
def menu():
'''左上角企业数量各资质统计、左上角获取经济指标数据、产业机构分布饼状图数据统计'''
req_dict = request.get_json()
district = req_dict.get("district") # 区县或者开发区名称
# 区县名称转换字典
district_dict = {
'沁水市': '沁水市',
'高平市': '高平市',
'陵川市': '陵川市',
'阳城市': '阳城市',
'泽州市': '泽州市',
'城区': '城区'
}
if not district or district == '晋城市':
try:
company = Company.query.filter_by(city="晋城市")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
else:
try:
company = Company.query.filter(Company.induzone == district_dict[district], Company.city == "晋城市")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 1. 左上角企业数量各资质统计
try:
# 晋城市
t_c5 = company.filter_by(isfive="1").count() # 500强
ssqy = company.filter_by(quoted_company="1").count() # 上市
if district != "晋城市":
gmys = Company.query.filter(Company.induzone == district_dict[district]).filter_by(
scale="1").count() # 规模(2-5) 622
else:
gmys = Company.query.filter_by(scale="1").count()
zjtx = company.filter_by(zjtg="1").count() # 专精特新
gxjs = company.filter_by(high_new="1").count() # 高新
kjzx = company.filter_by(tbe="1").count() # 科技型中小企业
dengl = company.filter_by(dengl="1").count() # 瞪羚
dujs = company.filter_by(unicorn="1").count() # 独角兽
table_data = [
{"name": "500强企业", "nums": t_c5},
{"name": "上市企业", "nums": ssqy},
{"name": "规模以上企业", "nums": gmys},
{"name": "专精特新企业", "nums": zjtx},
{"name": "高新技术企业", "nums": gxjs},
{"name": "科技型中小企业", "nums": kjzx},
{"name": "瞪羚企业", "nums": dengl},
{"name": "独角兽企业", "nums": dujs},
]
# 2. 左上角获取经济指标数据
jjzb_data = get_jjzb(district)
# 3. 产业机构分布饼状图数据统计
count_all = company.count()
if count_all == 0:
count_all = 1
count_mcq = company.filter_by(f_type=1).count() # 煤层气
count_gjd = company.filter_by(f_type=3).count() # 光机电
count_mtmhg = company.filter_by(f_type=4).count() # 煤炭煤化工
count_gtzz = company.filter_by(f_type=2).count() # 钢铁铸造
count_qyly = company.filter_by(f_type=5).count() # 全域旅游和康养
# count_xdfu = company.filter_by(f_type=6).count() # 现代服务业
# count_qt = count_all - count_mcq - count_gjd - count_mtmhg - count_gtzz - count_qyly - count_xdfu
count_qt = count_all - count_mcq - count_gjd - count_mtmhg - count_gtzz - count_qyly
mcq = int(count_mcq / count_all * 100)
gjd = int(count_gjd / count_all * 100)
mtmhg = int(count_mtmhg / count_all * 100)
gtzz = int(count_gtzz / count_all * 100)
qyly = int(count_qyly / count_all * 100)
# xdfu = int(count_xdfu / count_all * 100)
# qt = 100 - mcq - gjd - mtmhg - gtzz - qyly - xdfu
qt = 100 - mcq - gjd - mtmhg - gtzz - qyly
# 产业结构分布
industry = [
{"per": mtmhg, "name": "煤炭煤化工", "count": count_mtmhg},
{"per": mcq, "name": "煤层气", "count": count_mcq}, # {百分比，value}
{"per": gjd, "name": "光机电", "count": count_gjd},
{"per": gtzz, "name": "钢铁铸造", "count": count_gtzz},
{"per": qyly, "name": "全域旅游和康养", "count": count_qyly},
# {"per": qt + xdfu, "name": "其他", "count": count_qt + count_xdfu},
{"per": qt, "name": "其他", "count": count_qt},
]
data = {
"jjzb_data":jjzb_data, # 左上角经济指标数据
"table_data": table_data, # 左上角企业数据统计
"industry": industry # 产业结构分布饼状图数据
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 招商引资作战图、项目数量/金额分布图
@api_attract.route("/project", methods=["POST"])
def project():
req_dict = request.get_json()
district = req_dict.get("district") # 区县或者开发区名称
try:
project_map = []
industry_money = []
industry_nums = []
list1 = ["沁水市", "高平市", "陵川市", "阳城市", "泽州市", "城区"]
# 晋城市，点击区县之前默认数据
if not district or district == '晋城市':
for i in list1:
# 1.招商引资作战图数据
ss = Examine.query.filter_by(district=i).first()
project_map.append({"name": i,
"nums1": "{}亿元".format(ss.sign_finnish),
"add1": ss.sign_grade,
"nums2": "{}亿元".format(ss.start_finish),
"add2": ss.start_grade,
"nums3": "{}亿元".format(ss.invest_finish),
"add3": ss.invest_grade
})
# 产业数量/金额分布图数据
project_list = NewProject.query.filter_by(district=i).all()
for project in project_list:
industry_money.append({"name": project.type,
# "number": i.number,
"money": project.money})
industry_nums.append({"name": project.type,
# "money": i.money,
"number": project.number})
# 点击区县后的联动数据
else:
# 1.招商引资作战图数据
ss = Examine.query.filter_by(district=district).first()
project_map.append({"name": district,
"nums1": "{}亿元".format(ss.sign_finnish),
"add1": ss.sign_grade,
"nums2": "{}亿元".format(ss.start_finish),
"add2": ss.start_grade,
"nums3": "{}亿元".format(ss.invest_finish),
"add3": ss.invest_grade
})
# 产业数量/金额分布图数据
project_list = NewProject.query.filter_by(district=district).all()
for project in project_list:
industry_money.append({"name": project.type,
# "number": i.number,
"money": project.money})
industry_nums.append({"name": project.type,
# "money": i.money,
"number": project.number})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
data = {
"project_map": project_map, # 招商引资作战图
"industry_nums": industry_nums, # 已签约项目数量产业分布图
"industry_money": industry_money, # 已签约项目投资金额产业分布图
}
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 政策和重点项目 --- 重点项目需要改名称
@api_attract.route("/propol", methods=["POST"])
def propol():
req_dict = request.get_json()
district = req_dict.get("district") # 县区
district_dict = {'沁水市': '沁水市',
'高平市': '高平市',
'陵川市': '陵川市',
'阳城市': '阳城市',
'泽州市': '泽州市',
'城区': '城区'}
try:
project = Project.query.filter_by() # 重点项目
policy = InduPolicy.query.filter_by() # 政策
if not district and district == "晋城市":
# name_query = "project-propol"
# if redis_store.get(name_query) is not None:
# data = json.loads(redis_store.get(name_query))
# return jsonify(code=RET.OK, msg="获取成功", data=data)
project = project.filter_by()
policy_province = policy.filter_by(district="山西省").order_by(InduPolicy.pubdate.desc())
policy = policy.filter_by(district="晋城市").order_by(InduPolicy.pubdate.desc())
policy_2 = [{"name": i.name, "id": i.id, "distict": "山西省"} for i in policy_province.all()]
data_policy = [{"name": i.name, "id": i.id, "distict": "太原市"} for i in policy.all()]
data_project = [{"name": i.name, "id": i.id} for i in project.all()]
data = {
"project": data_project,
"policy": data_policy,
"policy_province": policy_2
}
# redis缓存
# redis_store.set(name_query, json.dumps(data))
# redis_store.expire(name_query, 1 * 24 * 3600)
else: # 区县、开发区
project = project.filter_by(district=district_dict[district])
policy = policy.filter_by(district=district_dict[district]).order_by(InduPolicy.pubdate.desc())
data_policy = [{"name": i.name, "id": i.id, "distict": district} for i in policy.all()]
data_project = [{"name": i.name, "id": i.id} for i in project.all()]
data = {
"project": data_project,
"policy": data_policy,
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DATAERR, msg="数据库错误")
# 获取区县的详情
@api_attract.route("/getInfo", methods=["POST"])
def get_info():
district_dict = {'晋城市': '晋城市',
'沁水市': '沁水市',
'高平市': '高平市',
'陵川市': '陵川市',
'阳城市': '阳城市',
'泽州市': '泽州市',
'城区': '城区'
}
req_dic = request.get_json()
district = req_dic.get("district") # 地区
if not district:
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
city = City.query.filter_by(area=district_dict[district]).first()
info = city.info
return jsonify(code=RET.OK, msg="查询成功", data=info)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 获取区县视频url
@api_attract.route("/video", methods=["POST"])
def attract_video():
req_dic = request.get_json()
district = req_dic.get("district")
if not district:
return jsonify(code=RET.PARAMERR, msg="参数不全")
district_dict = {'晋城市': '晋城市',
'沁水市': '沁水市',
'高平市': '高平市',
'陵川市': '陵川市',
'阳城市': '阳城市',
'泽州市': '泽州市',
'城区': '城区'
}
if district not in district_dict:
return jsonify(code=RET.DATAERR, msg="区县名称有误，没有相关视频")
district = district_dict[district]
video = Video.query.filter_by(district=district).first()
if video:
url = video.video_id
if url:
return jsonify(code=RET.OK, msg="查询成功", data={"url": url})
return jsonify(code=RET.NODATA, msg="暂无视频", data={"url": ""})
# 获取重点项目的详情，详情页
@api_attract.route("/keyProject", methods=["POST"])
def keyproject():
req_dic = request.get_json()
id = req_dic.get("id")
if not id:
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
project = Project.query.get(id)
data = {
"name": project.name,
"district": project.district,
"type": project.type,
"money": project.money,
"background": project.background,
"content": project.content,
"way": project.way,
"company": project.company,
"contact": project.contact,
"email": project.email
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 政策详情
@api_attract.route("/policyDetails", methods=["POST"])
def policy_details():
req_dic = request.get_json()
_id = req_dic.get("id")
if not _id:
return jsonify(code=RET.PARAMERR, msg="参数不全")
try:
policy = InduPolicy.query.get(_id)
data = {"name": policy.name,
"file": policy.file if policy.file else "-",
"category": policy.category if policy.category else "-",
"org": policy.org if policy.org else "-",
"industry": policy.industry if policy.industry else "-",
"district": policy.district if policy.district else "-",
"pubdate": str(policy.pubdate)[0:10] if policy.pubdate else "-",
"url": policy.url if policy.pubdate else "-",
"post_num": policy.post_num if policy.post_num else ""}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 列表展示左上角企业
@api_attract.route("/showListb", methods=["POST"])
def showListb():
district_dict = {'晋城市': '晋城市',
'沁水市': '沁水市',
'高平市': '高平市',
'陵川市': '陵川市',
'阳城市': '阳城市',
'泽州市': '泽州市',
'城区': '城区'
}
req_dic = request.get_json()
type = req_dic.get("type") # 1234567 （优质企业-500强-上市-规模-专精特新-高新-科技中小）
classify = req_dic.get("classify") # 1234 企业-学校-科研机构-传新平台
district = req_dic.get("district")
page = req_dic.get("page")
perpage = req_dic.get("perpage")
if not all([type, classify, district]):
return jsonify(code=RET.PARAMERR, msg="参数错误")
if not page:
page = 1
if not perpage:
perpage = 20
try:
# 企业
if classify == 1:
if district == "太原市":
company = Company.query.filter_by(city="太原市")
else:
# company = Company.query.filter(or_(Company.district == district_dict[district],
# Company.induzone == district_dict[district]))
company = Company.query.filter_by(city="太原市").filter(Company.induzone == district_dict[district])
size = company.count()
# if type == 1:
# company = company.order_by(Company.isfive.desc()).order_by(Company.tbe.desc()).order_by(
# Company.high_new.desc()).order_by(
# Company.quoted_company.desc()).order_by(Company.scale.desc())
if type == 1:
company = company.filter_by(isfive=1)
size = company.count()
if type == 2:
company = company.filter_by(quoted_company=1)
size = company.count()
if type == 3:
# company = company.filter_by(scale=1)
if district == "晋城市":
company = Company.query.filter_by(scale="1")
else:
company = Company.query.filter(Company.induzone == district_dict[district]).filter_by(scale="1")
size = company.count()
if type == 4:
company = company.filter_by(zjtg=1)
size = company.count()
if type == 5:
company = company.filter_by(high_new=1)
size = company.count()
if type == 6:
company = company.filter_by(tbe=1)
size = company.count()
if type == 7:
company = company.filter_by(dengl=1)
size = company.count()
if type == 8:
company = company.filter_by(unicorn=1)
size = company.count()
company = company.paginate(page, perpage).items
data = [{
"id": i.id,
"name": i.company_name,
"industry": i.company_industry if i.company_industry else "-",
"product": i.product if i.product else "-",
"build_date": i.build_date.strftime("%Y-%m-%d") if i.build_date else "-",
# "capital": i.capital if i.capital else "-",
"isfive": "500强企业" if i.isfive == "1" else "",
# "quoted_company": "上市企业" if i.quoted_company == "1" else "",
"quoted_company": i.public_sector if i.public_sector != "空" else "",
"scale": "规模以上企业" if i.scale == "1" else "",
"zjtg": "专精特新企业" if i.zjtg == "1" else "",
"high_new": "高新技术企业" if i.high_new == "1" else "",
"tbe": "科技型中小企业" if i.tbe == "1" else "",
"dengl": "瞪羚企业" if i.dengl == "1" else "",
"unicorn": "独角兽企业" if i.unicorn == "1" else "",
} for i in company]
data = {"data_list": data, "size": size}
# 学校
# elif classify == 2:
# if district == "太原市":
# college = College.query.filter()
# else:
# college = College.query.filter(or_(College.admin == district_dict[district],
# College.developarea == district_dict[district]))
# if type == 1:
# college = college.filter(or_(College.cateid == 1, College.cateid == 2))
# if type == 2:
# college = college.filter(College.cateid == 3)
# size = college.count()
# college = college.paginate(page, perpage).items
# data = [{
# "id": i.id,
# "name": i.name,
# "cateone": 1,
# "category": i.category if i.category else "-",
# "nature": i.nature if i.nature else "-",
# "buildate": i.buildate if i.buildate else "-",
# } for i in college]
# data = {"data_list": data, "size": size}
# # 科研机构:
# elif classify == 3:
# if district == "太原市":
# scientific = Scientific.query.filter_by()
# else:
# scientific = Scientific.query.filter(or_(Scientific.admin == district_dict[district],
# Scientific.developarea == district_dict[district]))
# size = scientific.count()
# scientific = scientific.paginate(page, perpage).items
# data = [{
# "id": i.id,
# "name": i.name,
# "cateone": 2,
# "type": "科研机构",
# "telephone": i.telephone if i.telephone else "-",
# } for i in scientific]
# data = {"data_list": data, "size": size}
# # 创新平台:
# elif classify == 4:
# if district == "太原市":
# lab = Lab.query.filter_by()
# else:
# lab = Lab.query.filter(or_(Lab.admin == district_dict[district],
# Lab.developarea == district_dict[district]))
# size = lab.count()
# lab = lab.paginate(page, perpage).items
# data = [{
# "id": i.id,
# "name": i.name,
# "type": i.cate,
# "cateone": 3
# } for i in lab]
# data = {"data_list": data, "size": size}
else:
data = {}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 企业信息详情(招商驾驶舱左上角各类企业详情)
@api_attract.route('/companyDetail', methods=['POST'])
def enterprise_detail():
'''
企业信息详情
:return:
'''
req_dict = request.get_json()
_id = req_dict.get("id") # 企业id
# 校验参数完整性
if not all([_id]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
company = Company.query.get(_id)
if company:
data = {"id": company.id,
"company_name": company.company_name,
"telephone": company.telephone if company.telephone else "-",
"web_site": company.web_site if company.web_site else "-",
"email": company.email if company.email else "-",
"address": company.address if company.address else "-",
"jwd": {"lng": company.lng if company.lng else "-",
"lat": company.lat if company.lat else "-"},
"company_info": company.company_info if company.company_info else "-",
"high_new": "高新技术企业" if company.high_new else "-",
"legal": company.legal if company.legal else "-",
"status": company.status if company.status else "-",
"build_date": str(company.build_date)[:10] if company.build_date else "-",
"capital": company.capital if company.capital else "-",
"social_code": company.social_code if company.social_code else "-",
"taking": company.takingn if company.takingn else "-",
"bao": company.bao_num if company.bao_num else "-",
"entype": company.entype if company.entype else "-",
"industry": company.company_industry if company.company_industry else "-",
"scope": company.business_scope if company.business_scope else "-",
"collect": "1",
"choice": "3"
}
else:
return jsonify(code=RET.NODATA, msg="查无数据")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 删除缓存
@api_attract.route("/deleteX", methods=["GET"])
def deleteX():
redis_store.delete("project-propol")
return jsonify(code=RET.OK, msg="删除成功")
# 删除缓存
@api_attract.route("/vis", methods=["GET"])
def vis():
redis_store.delete("project-propol")
return jsonify(code=RET.OK, msg={"remote_addr": request.remote_addr,
"X-Real-Ip": request.headers.get("X-Real-Ip"),
"X-Forwarded-For": request.headers.get("X-Forwarded-For"),
"HOST": request.headers.get("Host"),
"X-Forwarded-Proto": request.headers.get("X-Forwarded-Proto"),
})
apps/view_attract/view_changedata.py 0 → 100644
import json
from flask import request, jsonify, session, current_app
from sqlalchemy import func, desc, or_
from apps.models import *
from apps.view_attract import api_attract
from apps.utils.response_code import RET
from apps import db, constants, redis_store
# 改变城市数据
@api_attract.route("/changeCityData", methods=["POST"])
def changeCityData():
req_dic = request.get_json()
year = req_dic.get("年份")
district = req_dic.get("区县名称")
GDP = req_dic.get("地区生产总值")
size = req_dic.get("面积")
people = req_dic.get("人口")
investment = req_dic.get("固定资产投资")
retail = req_dic.get("社会消费品零售额")
public = req_dic.get("一般公共预算支出")
addscale = req_dic.get("规上工业增加值增速")
in_out = req_dic.get("进出口总额")
people_out = req_dic.get("居民人均可支配收入")
people_per = req_dic.get("居民消费价格指数")
info = req_dic.get("区县介绍")
if not all([year, district]):
return jsonify(code=RET.PARAMERR, msg="省份和年份是必填参数")
try:
city = City.query.filter_by(area=district, year=2020).first()
if GDP:
city.GDP = GDP
if size:
city.GDP = size
if people:
city.people = people
if investment:
city.investment = investment
if retail:
city.retail = retail
if public:
city.public = public
if addscale:
city.addscale = addscale
if in_out:
city.in_out = in_out
if people_out:
city.people_out = people_out
if people_per:
city.people_per = people_per
if info:
city.info = info
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
@api_attract.route("/addCityData", methods=["POST"])
def addCityData():
req_dic = request.get_json()
year = req_dic.get("年份")
district = req_dic.get("区县名称")
GDP = req_dic.get("地区生产总值")
size = req_dic.get("面积")
people = req_dic.get("人口")
investment = req_dic.get("固定资产投资")
retail = req_dic.get("社会消费品零售额")
public = req_dic.get("一般公共预算支出")
addscale = req_dic.get("规上工业增加值增速")
in_out = req_dic.get("进出口总额")
people_out = req_dic.get("居民人均可支配收入")
people_per = req_dic.get("居民消费价格指数")
info = req_dic.get("区县介绍")
if not all([year, district]):
return jsonify(code=RET.PARAMERR, msg="省份和年份是必填参数")
try:
city = City(area=district, year=year)
if GDP:
city.GDP = GDP
if size:
city.GDP = size
if people:
city.people = people
if investment:
city.investment = investment
if retail:
city.retail = retail
if public:
city.public = public
if addscale:
city.addscale = addscale
if in_out:
city.in_out = in_out
if people_out:
city.people_out = people_out
if people_per:
city.people_per = people_per
if info:
city.info = info
db.session.add(city)
db.session.commit()
return jsonify(code=RET.OK, msg="添加成功")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
@api_attract.route("/updateExamdata", methods=["POST"])
def updateExamdata():
req_dic = request.get_json()
year = req_dic.get("年份")
district = req_dic.get("区县名称")
month = req_dic.get("月份")
sign_finnish = req_dic.get("签约项目投资额完成额")
sign_grade = req_dic.get("签约项目投资额完成率")
start_finish = req_dic.get("开工项目计划投资额完成额")
start_grade = req_dic.get("开工项目计划投资额完成率")
invest_finish = req_dic.get("开工项目到位金额完成额")
invest_grade = req_dic.get("开工项目到位金额完成率")
if not all([district]):
return jsonify(code=RET.PARAMERR, msg="缺少必要参数")
try:
examine = Examine.query.filter_by(district=district)
if sign_finnish:
examine.sign_finnish = sign_finnish * 100
if sign_grade:
examine.sign_grade = sign_grade
if start_finish:
examine.start_finish = start_finish
if start_grade:
examine.start_grade = start_grade
if invest_finish:
examine.invest_finish = invest_finish * 10
if invest_grade:
examine.invest_grade = invest_grade
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Examine as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg='数据库错误')
# 更新饼图数据
@api_attract.route("/updateNewProject", methods=["POST"])
def updateNewProject():
req_dic = request.get_json()
district = req_dic.get("区县")
type = req_dic.get("行业")
number = req_dic.get("项目个数")
money = req_dic.get("金额")
if not all([district, type]):
return jsonify(code=RET.PARAMERR, msg="缺少必要参数")
try:
newproject = NewProject.query.filter_by(district=district, type=type).first()
if number:
newproject.number = number
if money:
newproject.money = money
db.session.commit()
except Exception as e:
db.session.rollbakck()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 添加饼图数据
@api_attract.route("/addNewProject", methods=["POST"])
def addNewProject():
req_dic = request.get_json()
district = req_dic.get("区县")
type = req_dic.get("行业")
number = req_dic.get("项目个数")
money = req_dic.get("金额")
if not all([district, type, number, money]):
return jsonify(code=RET.PARAMERR, msg="缺少必要参数")
try:
newproject = NewProject.query.filter_by(district=district, type=type).first()
if newproject:
return jsonify(code=RET.DATAEXIST, msg="数据已存在")
newproject = NewProject(district=district, type=type, number=number, money=money)
db.session.add(newproject)
db.session.commit()
except Exception as e:
db.session.rollbakck()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
apps/view_choose_address/__init__.py 0 → 100644
from flask import Blueprint
api_address = Blueprint("api_address",__name__)
# from . import view # 旧版
from . import view_choose_address # 新改
apps/view_choose_address/view.py 0 → 100644
from flask import current_app, request, jsonify
from apps.models import *
from apps.utils.response_code import RET
from apps.view_choose_address import api_address
import copy
import pymysql
# 选址评估，选择建议
@api_address.route("/advice", methods=["POST"])
def advice():
req_dict = request.get_json()
company = req_dict.get("company") # 企业名称（无作用）
industry = req_dict.get("industry") # 行业选择 nid
revenue = req_dict.get("revenue") # 营收 "2"
tax = req_dict.get("tax") # 税收 "1"
product = req_dict.get("product") # 主营产品 "药"
budget = req_dict.get('budget') # 预算 "22" # 大于
address = req_dict.get("address") # 地址 "小店区"
preference = req_dict.get("preference") # 选址偏好 [f,f,t,f,f,f]
if not all([company, industry, revenue, tax, product, budget, preference]):
return jsonify(code=RET.DATAERR, msg="数据不全")
list_zone = [] # 拼接sql的列表
if address:
list_zone.append("(region='{}'or development_zone = '{}')".format(address, address)) # 太原园区的字段 Induzone
list_zone.append(" (f_type is Null or f_type = {}) ".format(industry)) # 企业聚合度 CompanyIndustryPoint
list_zone.append("IFNULL(induzone.tax,0)<={}".format(tax)) # 园区税收要求 Induzone
list_zone.append("IFNULL(induzone.invest_power,0)<={}".format(budget)) # 投资强度 Induzone
list_zone = " and ".join(list_zone) # 拼接
sum_list = []
if preference[5] != "false": # 地区经济发展 ---GDP的打分
sum_list.append("IFNULL(induzone.gdp_point,0)")
if preference[1] != "false": # 产业聚集度 --- 产业的打分
# sum_list.append("IFNULL(company_industry_point,0)")
sum_list.append("IFNULL(company_industry_point.point,0)")
if preference[0] != "false": # 征服扶持力度 --- 政策数的打分
sum_list.append("IFNULL(induzone.policy_point,0)")
if preference[3] != "false": # 生活配套 -------水电打分
sum_list.append("IFNULL(induzone.warter_point,0)")
if preference[2] != "false": # 交通 -----交通打分
sum_list.append("IFNULL(induzone.electricity_point,0)")
if preference[4] != "false": # 园区配套服务 ----园区的学校，商业街，宾馆打分
sum_list.append("IFNULL(induzone.mall_point,0)")
sum_list.append("IFNULL(induzone.hotel_point,0)")
sum_list.append("IFNULL(induzone.school_point,0)")
# 拼接where请求
if list_zone:
list_zone = "where " + list_zone
# 拼接排序请求
sum_list = " + ".join(sum_list)
# print(sum_list, "-" * 10)
if sum_list:
sum_list = " order by " + sum_list + " desc"
# sql语句
sql = "select * from induzone " \
"LEFT OUTER JOIN company_industry_point on induzone.name = company_industry_point.district " \
+ list_zone + sum_list
print(sql)
try:
conn = pymysql.connect(host='39.100.39.50',
user='root',
password='Root@2020',
db='indutyty',
charset='utf8mb4')
cursor = conn.cursor()
data_num = cursor.execute(sql)
data_list = cursor.fetchall()
# print(sql)
if data_num > 3:
data_list = data_list[0:3]
data = [{"id": i[0],
"name": i[1],
"charge": i[9] if i[9] else "-",
"phone": i[10] if i[10] else "-",
"jwd": {"lng": i[13], "lat": i[14]}} for i in data_list]
# 没有查询结果的查找
if not data_list:
# 在第一条建议显示
data = [{"name": "对不起，没有找到合适的园区！"}]
cursor.close()
conn.close()
new_preference = copy.deepcopy(preference)
# del new_preference[2]
for i in range(0, len(data)):
if "true" in new_preference:
grade = 0
list_info = []
info = "根据{}算出结果，得分为{}"
s1 = Induzone.query.get(data[i]["id"])
if preference[5] != "false": # 地区经济发展 ---GDP的打分
grade += s1.gdp_point if s1.gdp_point else 0
list_info.append("地区经济发展")
if preference[1] != "false": # 产业聚集度 --- 产业的打分
# sum_list.append("IFNULL(company_industry_point,0)")
ss = CompanyIndustryPoint.query.filter_by(district=data[i]["name"], f_type=industry).first()
grade += ss.point if ss else 0
list_info.append("产业聚集度")
if preference[0] != "false": # 征服扶持力度 --- 政策数的打分
grade += s1.policy_point if s1.policy_point else 0
list_info.append("政府扶持力度")
if preference[3] != "false": # 生活配套 -------水电打分
grade += s1.warter_point if s1.warter_point else 0
list_info.append("生活配套")
# if preference[2] : # 交通 -----交通打分
# sum_list.append("IFNULL(induzone.electricity_point,0)")
if preference[2] !="false":
grade += s1.electricity_point if s1.electricity_point else 0
list_info.append("交通")
if preference[4] != "false": # 园区配套服务 ----园区的学校，商业街，宾馆打分
list_info.append("园区配套服务")
grade += s1.mall_point if s1.mall_point else 0
grade += s1.hotel_point if s1.hotel_point else 0
grade += s1.school_point if s1.school_point else 0
list_info = ",".join(list_info)
grade = grade / (0.2 * new_preference.count("true")) * 100
info = info.format(list_info, int(grade))
else:
info = "请选择选址偏好后得到更为精确定位"
data[i]["info"] = info
return jsonify(code=RET.OK, msg="选址成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 地图的处理
@api_address.route("/map", methods=["POST"])
def map():
req_dict = request.get_json()
district = req_dict.get("district")
try:
if not district:
# 获取所有的园区值
district_list = Induzone.query.filter_by().all()
data = [{"name": j.name, "jwd": {"lat": j.lat, "lng": j.lng}} for j in district_list]
return jsonify(code=RET.OK, msg="查找成功", data=data)
district_list = Induzone.query.filter_by(region=district)
data = [{"name": i.name, "jwd": {"lat": i.lat, "lng": i.lng}} for i in district_list]
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 获取行业筛选条件
@api_address.route("/downList", methods=["GET"])
def downlist():
"""一级二级行业分类"""
try:
industry = Industry.query.filter_by(statu=1).all()
data = [{
"name": i.name,
"id": i.nid,
} for i in industry]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
return jsonify(code=RET.OK, msg="查找成功", data=data)
apps/view_choose_address/view_choose_address.py 0 → 100644
import copy
import pymysql
from sqlalchemy import func, desc, or_
from flask import current_app, request, jsonify
from apps.models import Induzone, Industry, CompanyIndustryPoint
from apps.utils.response_code import RET
from apps.view_choose_address import api_address
# 选址评估，选择建议
@api_address.route("/advice", methods=["POST"])
def advice():
req_dict = request.get_json()
industry = req_dict.get("industry") # 所属行业选择 nid（必填）
product = req_dict.get("product") # 主营产品 "药" （必填）
budget = req_dict.get('budget') # 落地投资预算 "22" # 大于 （必填）
preference = req_dict.get("preference") # 选址偏好 [f,f,t,f,f,f]
revenue = req_dict.get("revenue") # 去年营收 "2" （非必填）
tax = req_dict.get("tax") # 去年税收 "1" （非必填）
address = req_dict.get("address") # 意向选址 "小店区" （非必填）
# print(address)
if not all([industry, product, budget, preference]):
return jsonify(code=RET.DATAERR, msg="数据不全")
try:
indu = Industry.query.filter_by(nid=industry).first()
if not indu:
return jsonify(code=RET.DATAERR, msg="参数错误")
industry_name = indu.oname
# zone = Induzone.query.outerjoin(CompanyIndustryPoint, Induzone.name == CompanyIndustryPoint.district). \
# filter(or_(Induzone.navigat.like("%{}%".format(industry_name)),
# Induzone.navigator.like("%{}%".format(industry_name)))). \
# filter(Induzone.invest_power <= budget)
zone = Induzone.query.filter(or_(Induzone.navigat.like("%{}%".format(industry_name)),
Induzone.navigator.like("%{}%".format(industry_name)))). \
filter(Induzone.invest_power <= budget)
if address: # 选址
zone = zone.filter(or_(Induzone.region == address, Induzone.development_zone == address))
if tax: # 税收
zone = zone.filter(Induzone.tax <= tax)
if preference[0] == "true": # 政府扶持力度 --- 政策数的打分
zone = zone.order_by(Induzone.policy_point.desc())
if preference[1] == "true": # 产业聚集度 --- 产业的打分
zone = zone.outerjoin(CompanyIndustryPoint, Induzone.name == CompanyIndustryPoint.district).filter(
CompanyIndustryPoint.f_type == industry).order_by(CompanyIndustryPoint.point.desc())
# zone = zone.order_by(CompanyIndustryPoint.point.desc())
if preference[2] == "true": # 交通 -----交通打分
zone = zone.order_by(Induzone.electricity_point.desc())
if preference[3] == "true": # 生活配套 -------水电打分、最低、普工、中级人员薪资
zone = zone.order_by(Induzone.warter_point.desc()).order_by(Induzone.wagelevel.desc()).order_by(
Induzone.worker.desc()).order_by(Induzone.middlemag.desc())
if preference[4] == "true": # 园区配套服务 ----园区的学校，商业街，宾馆打分
zone = zone.order_by(Induzone.mall_point.desc(), Induzone.hotel_point.desc(), Induzone.school_point.desc())
if preference[5] == "true": # 地区经济发展 ---GDP的打分
zone = zone.order_by(Induzone.gdp_point.desc())
zone = zone.group_by(Induzone.name)
result = zone.limit(3).all()
data = [{"id": i.id,
"name": i.name,
"charge": i.charge if i.charge else "-",
"phone": i.phone if i.phone else "-",
"jwd": {"lng": i.lng, "lat": i.lat}} for i in result]
# print(data)
# 没有查询结果的查找
# if not result:
# # 在第一条建议显示
# data = [{"name": "对不起，没有找到合适的园区！"}]
new_preference = copy.deepcopy(preference)
# del new_preference[2]
for i in range(0, len(data)):
if "true" in new_preference:
grade = 0
list_info = []
info = "根据{}算出结果，得分为{}"
s1 = Induzone.query.get(data[i]["id"])
if preference[5] != "false": # 地区经济发展 ---GDP的打分
grade += s1.gdp_point if s1.gdp_point else 0
list_info.append("地区经济发展")
if preference[1] != "false": # 产业聚集度 --- 产业的打分
# sum_list.append("IFNULL(company_industry_point,0)")
ss = CompanyIndustryPoint.query.filter_by(district=data[i]["name"], f_type=industry).first()
grade += ss.point if ss else 0
list_info.append("产业聚集度")
if preference[0] != "false": # 征服扶持力度 --- 政策数的打分
grade += s1.policy_point if s1.policy_point else 0
list_info.append("政府扶持力度")
if preference[3] != "false": # 生活配套 -------水电打分
grade += s1.warter_point if s1.warter_point else 0
list_info.append("生活配套")
# if preference[2] : # 交通 -----交通打分
# sum_list.append("IFNULL(induzone.electricity_point,0)")
if preference[2] != "false":
grade += s1.electricity_point if s1.electricity_point else 0
list_info.append("交通")
if preference[4] != "false": # 园区配套服务 ----园区的学校，商业街，宾馆打分
list_info.append("园区配套服务")
grade += s1.mall_point if s1.mall_point else 0
grade += s1.hotel_point if s1.hotel_point else 0
grade += s1.school_point if s1.school_point else 0
list_info = ",".join(list_info)
grade = grade / (0.2 * new_preference.count("true")) * 100
info = info.format(list_info, int(grade))
else:
info = "请选择选址偏好后得到更为精确定位"
data[i]["info"] = info
# 没有查询结果的查找
if not result:
# 在第一条建议显示
data = [{"name": "对不起，没有找到合适的园区！"}]
return jsonify(code=RET.OK, msg="选址成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 地图的处理
@api_address.route("/map", methods=["POST"])
def map():
req_dict = request.get_json()
district = req_dict.get("district")
try:
if not district:
# 获取所有的园区值
district_list = Induzone.query.filter_by().all()
data = [{"name": j.name, "jwd": {"lat": j.lat, "lng": j.lng}} for j in district_list]
return jsonify(code=RET.OK, msg="查找成功", data=data)
district_list = Induzone.query.filter_by(region=district)
data = [{"name": i.name, "jwd": {"lat": i.lat, "lng": i.lng}} for i in district_list]
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 获取行业筛选条件
@api_address.route("/downList", methods=["GET"])
def downlist():
"""一级二级行业分类"""
try:
industry = Industry.query.filter_by(statu=1).all()
data = [{
"name": i.name,
"id": i.nid,
} for i in industry]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
return jsonify(code=RET.OK, msg="查找成功", data=data)
apps/view_mobile/__init__.py 0 → 100644
from flask import Blueprint
api_mobile = Blueprint("api_mobile",__name__)
from . import view_atlas
from . import view_user
from . import mobile_attract
from . import mobile_360
from . import mobile_collect
from . import mobile_item
from . import mobile_choose
from . import mobile_homepage
\ No newline at end of file
apps/view_mobile/mobile_360.py 0 → 100644
import os
import json
from elasticsearch import Elasticsearch
from flask import request, jsonify, current_app
from apps.models import *
from apps.view_mobile import api_mobile
from apps.util import login_required, verify_token
from apps.utils.response_code import RET
def body_qualificat(s, j):
body = {
"query": {
"bool": {
"must": {"match":
{"{}": "{}".format(s, j)}
}
}
}
}
return body
def body_type(s):
body = {
"query": {
"bool": {
"must": {"match":
{"entypeid": "{}".format(s)}
}
}
}
}
return body
def create_body(page, page_size, args_query, args_date, args_term):
'''
:param page:
:param page_size:
:param args_query:
:param args_date:
:param args_term:
:return:
'''
body = {
"query": {
"bool": {
"filter": {
"range": {
"build_date": {
}
}
},
"must": [
{"multi_match": {
"query": "{}".format(args_query["query"]),
"type": "best_fields",
"fields": [
"product^1.0",
"company_name^1.0",
"industry^1.0"
],
"tie_breaker": 0.3
}
},
]
}
},
"from": page,
"size": page_size,
"sort": [],
"aggs": {},
"_source": [
# 'all_info',
'industry', 'build_date', 'register_money_nums', 'product',
'company_name', "mysql_id"
],
"highlight": {
"fields": {
"product": {"type": "plain"},
"company_name": {"type": "plain"},
"industry": {"type": "plain"}
}
}
}
if args_date:
body["query"]["bool"]["filter"]["range"]["build_date"]["gte"] = args_date["build_date"][0]
body["query"]["bool"]["filter"]["range"]["build_date"]["lte"] = args_date["build_date"][1]
for k, v in args_term.items():
body["query"]["bool"]["must"].append({"term": {"{}".format(k): "{}".format(v)}})
return body
# 360企业画像两个静态表
def openDists():
upload_path = os.path.dirname(os.path.dirname(__file__)) + "/utils/json/city.json"
with open(upload_path, encoding="utf-8") as f:
data = json.load(f)
return data
# 地域层级数据分级获取
@api_mobile.route('/mobileGetRegion', methods=['GET'])
def mobile_get_region():
try:
data = openDists()
if len(data) > 0:
return jsonify(code=200, msg="查找成功", data=data)
else:
return jsonify(code=201, msg="暂时没有数据")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="查找错误")
@api_mobile.route('/mobileField', methods=['GET'])
# @login_required
def mobile_field():
'''
全国企业条件选择导航获取
:return:
'''
try:
property = Property.query.filter_by(statu=1)
typy = property.filter_by(sid=1, statu=1).all()
qualificat = property.filter_by(sid=2, statu=1).all()
quoted = property.filter_by(sid=3, statu=1).all()
financ = property.filter_by(sid=4, statu=1).all()
# options: [{ value: "选项1", label: "无数据" },{ value: "选项2", label: "3333" }],
data = {"entype": [{"name": "请选择", "id": ""}] + [{"name": i.name, "id": i.nid} for i in typy],
"qualificat": [{"name": "请选择", "id": ""}] + [{"name": i.name, "id": i.nid} for i in qualificat],
"quoted": [{"name": "请选择", "id": ""}] + [{"name": i.name, "id": i.nid} for i in quoted],
"financ": [{"name": "请选择", "id": ""}] + [{"name": i.name, "id": i.nid} for i in financ],
"buildate": [{"name": "请选择", "id": ""}] + [{"name": "1-3年", "id": 1}, {"name": "3-5年", "id": 2},
{"name": "5-8年", "id": 3}, {"name": "8-10年", "id": 4},
{"name": "10-15年", "id": 5}, {"name": "15年以上", "id": 6}],
"capital": [{"name": "请选择", "id": ""}] + [{"name": "100万以内", "id": 1}, {"name": "100万-500万", "id": 2},
{"name": "500万-1000万", "id": 3},
{"name": "1000万-5000万", "id": 4},
{"name": "1000万-1亿", "id": 5}, {"name": "1亿以上", "id": 6}]
}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", options=data)
# 搜索接口
@api_mobile.route("/mobileSearch", methods=["POST"])
@login_required
def mobile_search():
req_dict = request.get_json()
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
# ##es的查询，。。。。
# user_id = 2
qualificat = req_dict.get("qualificat")
entypeid = req_dict.get("entypeid")
area = req_dict.get("area")
province = None
city = None
district = None
if area:
province = area[0]
city = area[1]
district = area[2]
capital_id = req_dict.get("capital_id")
public_id = req_dict.get("public_id")
financ_id = req_dict.get("financ_id")
yearid = req_dict.get("yearid")
print(yearid)
company = req_dict.get("company")
args_query = dict()
args_date = dict()
args_term = dict()
# #每页个数
per_page = req_dict.get("per_page")
page = req_dict.get("page")
if not req_dict.get("per_page"):
per_page = 10
per_page = int(per_page)
# 页数
if not page:
page = 1
page = int(page)
page = (page - 1) * per_page
args_query["query"] = "公司"
# 搜索框
if company:
args_query["query"] = company
try:
user = User.query.get(user_id)
b = []
if user.searchlist:
for j in user.searchlist:
b.append(j.history)
if company in b:
user.searchlist.remove(user.searchlist[b.index(company)])
if len(b) > 5:
user.searchlist.remove(user.searchlist[0])
search = SearchList(history=company)
db.session.add(search)
user.searchlist.append(search)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 公司类型
if entypeid:
args_term['entypeid'] = entypeid
# 注册资本
if capital_id:
args_term['capital_id'] = capital_id
# 上市状态
if public_id:
args_term['public_id'] = public_id
# 省
if province:
args_term['province'] = province
# 市
if city:
args_term['city'] = city
# 区
if district:
args_term['district'] = district
# 公司资质
if qualificat:
if qualificat == 1:
args_term['high_new'] = 1
if qualificat == 2:
args_term['tbe'] = 1
if qualificat == 3:
args_term['quoted_company'] = 1
if qualificat == 4:
args_term['isfive'] = 1
if qualificat == 5:
args_term['unicorn'] = 1
if qualificat == 6:
args_term['dengl'] = 1
# 成立时间
if yearid:
args_term['yearid'] = yearid
if financ_id:
args_term['financ_id'] = financ_id
body = create_body(page, per_page, args_query, args_date, args_term)
if not company:
del body["query"]["bool"]["must"][0]
try:
es = Elasticsearch([{'host': '39.100.39.50', 'port': 9200}])
data = es.search(index="ty_360", body=body)
data_list = []
# 数据的列表添加进去
for i in data["hits"]['hits']:
if company:
# 判断高亮，然后添加
data_list.append({
"company": i["highlight"]["company_name"][0] if "company_name" in i["highlight"] else i["_source"][
"company_name"],
"product": i["highlight"]["product"][0] if "product" in i["highlight"] else i["_source"]["product"],
"industry": i["highlight"]["industry"][0] if "industry" in i["highlight"] else i["_source"][
"industry"],
"money": "{}万元".format(i["_source"]["register_money_nums"]),
"createtime": i["_source"]["build_date"],
"id": i["_source"]["mysql_id"],
"choice": 2
})
else:
data_list.append({
"company": i["_source"]["company_name"],
"product": i["_source"]["product"],
"industry": i["_source"]["industry"],
"money": "{}万元".format(i["_source"]["register_money_nums"]),
"createtime": i["_source"]["build_date"],
"id": i["_source"]["mysql_id"],
"choice": 2,
})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="es数据库错误")
data = {
"data": data_list
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
# 搜索历史接口
@api_mobile.route("/mobileSearchList", methods=["GET"])
@login_required
def mobile_search_list():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
# user_id = 2
try:
user = User.query.get(user_id)
data = {
"search": [i.history for i in user.searchlist]
}
data["search"] = data["search"][::-1]
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 删除搜索历史接口
@api_mobile.route("/deleteSearchlist", methods=["GET"])
@login_required
def delete_search_list():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
# user_id = 2
try:
user = User.query.get(user_id)
for i in user.searchlist:
user.searchlist.remove(i)
db.session.commit()
return jsonify(code=RET.OK, msg="查询成功")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
apps/view_mobile/mobile_attract.py 0 → 100644
from flask import request, jsonify, session, current_app
from sqlalchemy import func, desc, or_
from apps.models import *
from apps.view_mobile import api_mobile
from apps.utils.response_code import RET
@api_mobile.route("/attractMenu", methods=["POST"])
def attract_menu():
req_dict = request.get_json()
district = req_dict.get("district")
print(district)
if not district or district == "太原市":
district = None
if district == None:
try:
company = Company.query.filter_by(city="太原市")
data = City.query.filter_by().first()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
else:
try:
company = Company.query.filter(or_(Company.district == district, Company.induzone == district),
Company.city == "太原市")
data = City.query.filter_by(area=district).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
try:
count_all = company.count()
zczb = db.session.query(func.sum(Company.capital_nums)).filter().all()
t_c5 = company.filter_by(isfive="1").count()
ssqy = company.filter_by(quoted_company="1").count()
gmys = company.filter_by(scale="1").count()
zjtx = company.filter_by(zjtg="1").count()
gxjs = company.filter_by(high_new="1").count()
kjzx = company.filter_by(tbe="1").count()
zczb = zczb[0][0]
college = College.query.filter_by()
scientific = Scientific.query.filter_by().count()
lab = Lab.query.filter_by().count()
college_211 = college.filter_by(cateid=1).count()
college_master = college.filter_by(cateid=2).count()
college_associate = college.filter_by(cateid=3).count()
if district:
zczb = db.session.query(func.sum(Company.capital_nums)). \
filter(or_(Company.district == district, Company.induzone == district)).all()
zczb = zczb[0][0]
# print(zczb)
college = College.query.filter(or_(College.admin == district, College.developarea == district))
scientific = Scientific.query.filter(
or_(Scientific.admin == district, Scientific.developarea == district)).count()
lab = Lab.query.filter(or_(Lab.admin == district, Lab.developarea == district)).count()
college_211 = college.filter_by(cateid=1).count()
college_master = college.filter_by(cateid=2).count()
college_associate = college.filter_by(cateid=3).count()
table_data = [
{"name": "优质企业", "nums": count_all},
{"name": "注册资本", "nums": "{}亿元".format(round(zczb / 10000, 2)) if zczb else "-"},
{"name": "500强企业", "nums": t_c5},
{"name": "上市企业", "nums": ssqy},
{"name": "规模以上企业", "nums": gmys},
{"name": "山西专精特新企业数", "nums": zjtx},
{"name": "高新技术企业", "nums": gxjs},
{"name": "科技型中小企业数", "nums": kjzx},
{"name": "高等院校", "nums": college_master + college_211},
{"name": "高职专科", "nums": college_associate},
{"name": "科研机构", "nums": scientific},
{"name": "创新平台", "nums": lab}
]
city_data = [
{"nums": "{}亿元".format(round(data.GDP / 10000, 2)) if data.GDP else "-", "name": "GDP"},
{"nums": "{}亿元".format(round(data.investment / 10000, 2)) if data.investment else "-", "name": "固定资产投资"},
{"nums": "{}亿元".format(round(data.retail / 10000, 2)) if data.retail else "-", "name": "社会消费零售额"},
{"nums": "{}亿元".format(round(data.public / 10000, 2)) if data.public else "-", "name": "一般公共预算支出"}
]
data = {
"table_data": table_data,
"city_data": city_data,
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 政策和重点项目 --- 重点项目需要改名称
@api_mobile.route("/attractPropol", methods=["POST"])
def attract_propol():
req_dict = request.get_json()
district = req_dict.get("district") # 县区
project = Project.query.filter_by()
policy = InduPolicy.query.filter_by()
try:
if district and district != "太原市":
project = Project.query.filter_by(district=district)
policy = InduPolicy.query.filter_by(district=district)
data_project = [{"name": i.name, "id": i.id} for i in project.all()]
data_policy = [{"name": i.name, "id": i.id} for i in policy.all()]
data = {
"project": data_project,
"policy": data_policy,
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DATAERR, msg="数据库错误")
# 获取重点企业的详情，详情页
@api_mobile.route("/attractKeyProject", methods=["POST"])
def attract_keyproject():
req_dic = request.get_json()
id = req_dic.get("id")
if not id:
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
project = Project.query.get(id)
data = {
"name": project.name,
"district": project.district,
"type": project.type,
"money": project.money,
"background": project.background,
"content": project.content,
"way": project.way,
"company": project.company,
"contact": project.contact,
"email": project.email
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 工程图表两个
@api_mobile.route("/attractProject", methods=["POST"])
def attract_project():
req_dict = request.get_json()
district = req_dict.get("district")
try:
list1 = NewProject.query.filter_by(district="太原市").all()
project_industry = []
for i in list1:
ss = NewProject.query.filter_by(type=i.type).first()
project_industry.append({"name": ss.type,
"number": ss.number,
"money": ss.money})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
data = {
"project_industry": project_industry,
}
return jsonify(code=RET.OK, msg="获取成功", data=data)
apps/view_mobile/mobile_choose.py 0 → 100644
from flask import current_app, request, jsonify
from apps.models import *
from apps.utils.response_code import RET
from apps.view_mobile import api_mobile
import pymysql
def judge_number(s):
if "." in str(s):
d = s.split(".")
if len(d) == 2:
for i in d:
if i.isdigit():
pass
else:
return False
return True
return False
else:
return str(s).isdigit()
# 选址评估，选择建议
@api_mobile.route("/chooseAdvice", methods=["POST"])
def choose_advice():
req_dict = request.get_json()
company = req_dict.get("company")
industry = req_dict.get("industry")
revenue = req_dict.get("revenue")
tax = req_dict.get("tax")
product = req_dict.get("product")
budget = req_dict.get('budget')
address = req_dict.get("address")
preference = req_dict.get("preference")
if not all([company, industry, revenue, tax, product, budget, preference]):
return jsonify(code=RET.DATAERR, msg="数据不全")
for i in range(0, 3):
if not judge_number([revenue, tax, budget][i]):
return jsonify(code=RET.DATAERR, msg=["营收应该为数字", "税收应该为数字", "预算应该为数字"][i])
list_zone = []
if address and address != "太原市":
list_zone.append("(region='{}'or development_zone = '{}')".format(address, address))
list_zone.append(" (f_type is Null or f_type = {}) ".format(industry))
list_zone.append("IFNULL(induzone.tax,0)<={}".format(tax))
list_zone.append("IFNULL(induzone.invest_power,0)<={}".format(budget))
list_zone = " and ".join(list_zone)
sum_list = []
if preference[5] != "false": # 地区经济发展 ---GDP的打分
sum_list.append("IFNULL(induzone.gdp_point,0)")
if preference[1] != "false": # 产业聚集度 --- 产业的打分
# sum_list.append("IFNULL(company_industry_point,0)")
sum_list.append("IFNULL(company_industry_point.point,0)")
if preference[0] != "false": # 征服扶持力度 --- 政策数的打分
sum_list.append("IFNULL(induzone.policy_point,0)")
if preference[3] != "false": # 生活配套 -------水电打分
sum_list.append("IFNULL(induzone.warter_point,0)")
# if preference[2] : # 交通 -----交通打分
# sum_list.append("IFNULL(induzone.electricity_point,0)")
if preference[4] != "false": # 园区配套服务 ----园区的学校，商业街，宾馆打分
sum_list.append("IFNULL(induzone.mall_point,0)")
sum_list.append("IFNULL(induzone.hotel_point,0)")
sum_list.append("IFNULL(induzone.school_point,0)")
# 拼接where请求
if list_zone:
list_zone = "where " + list_zone
# 拼接排序请求
sum_list = " + ".join(sum_list)
if sum_list:
sum_list = " order by " + sum_list + " desc"
# sql语句
sql = "select * from induzone " \
"LEFT OUTER JOIN company_industry_point on induzone.name = company_industry_point.district " \
+ list_zone + sum_list
try:
conn = pymysql.connect(host='39.100.39.50',
user='root',
password='Root@2020',
db='indutyty',
charset='utf8')
cursor = conn.cursor()
# print(sql)
data_num = cursor.execute(sql)
data_list = cursor.fetchall()
# print(sql)
if data_num > 3:
data_list = data_list[0:3]
data = [{"id": i[0],
"name": i[1],
"charge": i[9] if i[9] else "-",
"phone": i[10] if i[10] else "-",
"jwd": {"lng": i[13], "lat": i[14]}} for i in data_list]
# 没有查询结果的查找
if not data_list:
data = [{"name": "对不起，没有找到合适的园区！"}]
cursor.close()
conn.close()
return jsonify(code=RET.OK, msg="选址成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 地图的处理
@api_mobile.route("/chooseMap", methods=["POST"])
def choose_map():
req_dict = request.get_json()
district = req_dict.get("district")
try:
if not district:
# 获取所有的园区值
district_list = Induzone.query.filter_by().all()
data = [{"name": j.name, "jwd": {"lat": j.lat, "lng": j.lng}} for j in district_list]
return jsonify(code=RET.OK, msg="查找成功", data=data)
district_list = Induzone.query.filter_by(region=district)
data = [{"name": i.name, "jwd": {"lat": i.lat, "lng": i.lng}} for i in district_list]
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 获取下拉列表
@api_mobile.route("/chooseDownList", methods=["GET"])
def choose_downlist():
try:
industry = Industry.query.filter_by(statu=1).all()
data = [{
"name": i.name,
"id": i.nid,
} for i in industry]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
return jsonify(code=RET.OK, msg="查找成功", data=data)
apps/view_mobile/mobile_collect.py 0 → 100644
import re
import random
import threading
from flask import jsonify, request, current_app
from flask_mail import Mail, Message
from apps import redis_store, creat_app
from apps.view_mobile import api_mobile
from apps.models import *
from apps.utils.response_code import RET
from apps.util import login_required,verify_token
from apps.utils.send_phone_info import send_code_new
@api_mobile.route("/mobilceCollect",methods = ["POST"])
#@login_required
def mobile_collect_com():
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
user_id = 3
req_dict = request.get_json()
page = req_dict.get("page")
per_page = req_dict.get("per_page")
classify = req_dict.get("classify")
choice = req_dict.get("choice")
if not page:
page = 1
if not per_page:
per_page = 10
if not all([classify,choice]):
return jsonify(code = RET.PARAMERR,msg= "数据不全")
# 判断是企业还是行业关注，企业1，行业0
if classify == 1:
company = []
try:
user = User.query.get(user_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
if choice == "2":
try:
maxnum = len(user.enterprise)
company_list = user.enterprise[(page - 1) * per_page:page * per_page]
for i in company_list:
create_time = UserEnterprise.query.filter_by(enterprise_id=i.id, user_id=user_id).first()
company.append({
"id": i.id,
"company_name": i.company_name,
"create_time": create_time.create_time.strftime('%Y-%m-%d %H:%M:%S'),
"build_date": i.build_date.strftime("%Y-%m-%d") if i.build_date else "-",
"legal":i.legal if i.legal else "-",
"money":"{}万元".format(i.capital_nums) if i.capital_nums else "-"
})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
data = {
"ob_list": company,
"maxnum": maxnum
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
else:
maxnum = len(user.company)
company_list = user.company[(page - 1) * per_page:page * per_page]
try:
for i in company_list:
create_time = UserCompany.query.filter_by(company_id=i.id, user_id=user_id).first()
company.append({
"id": i.id,
"company_name": i.company_name,
"create_time": create_time.create_time.strftime('%Y-%m-%d %H:%M:%S'),
"build_date": i.build_date.strftime("%Y-%m-%d") if i.build_date else "-",
"legal":i.legal if i.legal else "-",
"money":"{}万元".format(i.capital_nums) if i.capital_nums else "-"
})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
data = {
"ob_list": company,
"maxnum": maxnum
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
# 行业
try:
user = User.query.get(user_id)
maxnum = len(user.industry)
industry = []
industry_list = user.industry[(page - 1) * per_page:page * per_page]
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
try:
for i in industry_list:
# 查询关注时间
indu = UserIndustry.query.filter_by(industry_id=i.id, user_id=user_id).first()
industry.append({
"id": i.id,
"industry_name": i.name,
"create_time": indu.create_time.strftime("%Y-%m-%d"),
"count": i.entities if i.entities else 0
})
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
data = {
"ob_list": industry,
"maxnum": maxnum
}
return jsonify(code=200, msg="查找成功", data=data)
#取消收藏
@api_mobile.route("/mobileDelete", methods=["POST"])
@login_required
def mobile_delete():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
req_dict = request.get_json()
id = req_dict.get("id")
classify = req_dict.get("classify")
choice = req_dict.get("choice")
#print(id,classify,choice)
if not all([id,classify,choice]):
return jsonify(code=RET.PARAMERR, msg="数据不全")
# id = g.id
if classify == 1:
if choice == "2":
# 删除全国数据
#pass
try:
company_user = UserEnterprise.query.filter_by(enterprise_id=id, user_id=user_id).first()
db.session.delete(company_user)
db.session.commit()
return jsonify(code = RET.OK,msg = "取关成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
else:
try:
company_user = UserCompany.query.filter_by(company_id=id, user_id=user_id).first()
db.session.delete(company_user)
db.session.commit()
return jsonify(code = RET.OK,msg = "取关成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 删除企业数据
try:
industry_user = UserIndustry.query.filter_by(industry_id=id, user_id=user_id).first()
db.session.delete(industry_user)
db.session.commit()
return jsonify(code=RET.OK, msg="取关成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code = RET.DBERR,msg = "数据库错误")
\ No newline at end of file
apps/view_mobile/mobile_homepage.py 0 → 100644
import os
import json
from elasticsearch import Elasticsearch
from flask import request, jsonify, current_app
from apps.models import *
from apps.view_mobile import api_mobile
from apps.util import login_required, verify_token
from apps.utils.response_code import RET
def create_body(page, page_size, args_query, args_date, args_term):
'''
:param page:
:param page_size:
:param args_query:
:param args_date:
:param args_term:
:return:
'''
body = {
"query": {
"bool": {
"filter": {
"range": {
"build_date": {
}
}
},
"must": [
{"multi_match": {
"query": "{}".format(args_query["query"]),
"type": "best_fields",
"fields": [
"product^1.0",
"company_name^1.0",
"industry^1.0"
],
"tie_breaker": 0.3
}
},
]
}
},
"from": page,
"size": page_size,
"sort": [],
"aggs": {},
"_source": [
#'all_info',
'industry', 'build_date', 'register_money_nums', 'product',
'company_name',"mysql_id"
],
"highlight": {
"fields": {
"product": {"type": "plain"},
"company_name": {"type": "plain"},
"industry": {"type": "plain"}
}
}
}
if args_date:
body["query"]["bool"]["filter"]["range"]["build_date"]["gte"] = args_date["build_date"][0]
body["query"]["bool"]["filter"]["range"]["build_date"]["lte"] = args_date["build_date"][1]
for k, v in args_term.items():
body["query"]["bool"]["must"].append({"term": {"{}".format(k): "{}".format(v)}})
return body
#搜索接口
@api_mobile.route("/mobileSearchTy", methods=["POST"])
@login_required
def mobile_search_ty():
req_dict = request.get_json()
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
company = req_dict.get("company")
if not company:
return jsonify(code = RET.PARAMERR,msg = "数据库错误")
args_query = dict()
args_date = dict()
args_term = dict()
# #每页个数
per_page = req_dict.get("per_page")
page = req_dict.get("page")
if not req_dict.get("per_page"):
per_page = 10
per_page = int(per_page)
# 页数
if not page:
page = 1
page = int(page)
args_query["query"] = company
try:
user = User.query.get(user_id)
b = []
if user.searchlist:
for j in user.searchlist:
b.append(j.history)
if company in b:
user.searchlist.remove(user.searchlist[b.index(company)])
if len(b) > 5:
user.searchlist.remove(user.searchlist[0])
search = SearchList(history=company)
db.session.add(search)
user.searchlist.append(search)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
body = create_body(page, per_page, args_query, args_date, args_term)
try:
es = Elasticsearch([{'host': '39.100.39.50', 'port': 9200}])
data = es.search(index="ty_com", body=body)
data_list = []
#数据的列表添加进去
for i in data["hits"]['hits']:
if company:
# 判断高亮，然后添加
data_list.append({
"company": i["highlight"]["company_name"][0] if "company_name" in i["highlight"] else i["_source"]["company_name"],
"product": i["highlight"]["product"][0] if "product" in i["highlight"] else i["_source"]["product"],
"industry": i["highlight"]["industry"][0] if "industry" in i["highlight"] else i["_source"]["industry"],
"money": "{}万元".format( i["_source"]["register_money_nums"]),
"createtime": i["_source"]["build_date"],
"id": i["_source"]["mysql_id"],
"choice": 1
})
else:
data_list.append({
"company": i["_source"]["company_name"],
"product": i["_source"]["product"],
"industry": i["_source"]["industry"],
"money": "{}万元".format(i["_source"]["register_money_nums"]),
"createtime": i["_source"]["build_date"],
"id": i["_source"]["mysql_id"],
"choice":1,
})
except Exception as e:
current_app.logger.error(e)
return jsonify(code = RET.DBERR,msg= "es数据库错误")
data = {
"data": data_list
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
apps/view_mobile/mobile_item.py 0 → 100644
import os
import time
import datetime
import re
import pandas as pd
from flask import jsonify, request, current_app
from sqlalchemy import or_, and_, desc
from apps.models import *
from apps.util import login_required,verify_token
from apps.view_mobile import api_mobile
from apps.utils.response_code import RET
from dateutil.relativedelta import relativedelta
def get_year_month(year,month):
year = int(year)
month = int(month)
if month == 12:
year += 1
month = 1
else:
year = year
month += 1
return year,month
def get_ininvest_id(x):
x = int(x)
if x < 0:
return 0
if x <= 1:
return 1
if x <= 10:
return 2
if x <= 50:
return 3
if x < 100:
return 4
return 5
# 招商资源管理
# 新增项目详情页的下拉列表
@api_mobile.route("/mobileInList", methods=["GET"])
# @login_required
def mobile_in_list():
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
user_id = 3
try:
user = User.query.get(user_id)
role = user.flag
if role != 2:
return jsonify(code = RET.ROLEERR,msg = "无权限查看此内容")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
try:
attract = Attract.query.filter_by(statu=1)
industry_list = attract.filter_by(sid=1).all() # 行业表
stage_list = attract.filter_by(sid=2).all() # 项目阶段表
invest = [{"name":"请选择","id":""},{"name":"1亿元以下","id":1},{"name":"1-10亿元","id":2},
{"name":"10-50亿元","id":3},{"name":"50-100亿元","id":4},
{"name":"100亿元以上","id":5}]
unit = user.unit # 操作人的机构
government = Government.query.filter_by(name = unit).first()
section_list = government.sections
industry = [{"name": i.name, "industry_id": i.nid} for i in industry_list]
industry = [{"name":"请选择","industry_id":""}] + industry
stage = [{"name": i.name, "stage_id": i.nid} for i in stage_list]
stage = [{"name":"请选择","stage_id":""}]+stage
section = [{"name": i.name, "section_id": i.id} for i in section_list]
section = [{"name":"请选择","section_id":""}] + section
data = {
"industry": industry,
"stage": stage,
"invest":invest,
"section":section
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 招商资源管理页面的详情页
@api_mobile.route("/mobileInItem", methods=["POST"])
# @login_required
def mobile_in_item():
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
user_id = 3
try:
user = User.query.get(user_id)
unit = user.unit # 用户所在的部门
role = user.flag
if role != 2:
return jsonify(code=RET.ROLEERR, msg="无权限查看此内容")
role = user.role.role
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
req_dic = request.get_json()
page = req_dic.get("page") # 页数
perpage = req_dic.get("perpage") # 每页个数
stage_id = req_dic.get("stage_id") # 项目进展
indu_id = req_dic.get("indu_id") # 行业
invest_id = req_dic.get("invest_id") # 投资
section = req_dic.get("section") # 部门
search = req_dic.get("search") # 搜索栏搜索的值
#order = req_dic.get("order") # 按照投资额的顺序 #1为顺序，2为倒序
if search:
try:
user = User.query.get(user_id)
b = []
print(user.searchitem)
if user.searchitem:
for j in user.searchitem:
b.append(j.history)
if search in b:
user.searchitem.remove(user.searchitem[b.index(search)])
if len(b) > 5:
user.searchitem.remove(user.searchitem[0])
sear = SearchItem(history=search)
db.session.add(sear)
user.searchitem.append(sear)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg='数据库错误')
# 获取当前账号的权限制
try:
item = Item.query.filter_by()
if role[0] == "1":
item = item.filter_by(unit=unit)
# 权限查找
if role[0] == "2": # 部级
item = item.filter_by(section=user.section)
if role[0] == "3": # 个人
item = item.filter(or_(Item.share.like("%--" + str(user_id) + "--%"), Item.user_id == user_id))
if not page:
page = 1
if not perpage:
perpage = 10
if stage_id:
item = item.filter_by(stage_id=stage_id)
if indu_id:
item = item.filter_by(indu_id=indu_id)
if invest_id:
item = item.filter_by(invest_id=invest_id)
if section:
if section != "请选择":
item = item.filter_by(section=section)
if search:
item = item.filter(or_(Item.company_name.like("%" + search + "%")
, Item.name.like("%" + search + "%")))
# if order == 2:
# item = item.order_by(desc("invest"))
# else:
# item = item.order_by("invest")
item = item.order_by(desc("id"))
maxnum = len(item.all())
item = item.paginate(page, perpage).items
data_list = []
#status_list = ["", "未上报", "已上报", "已驳回", "已通过"]
for i in item:
# status = i.status
# if not i.status:
# status = 0
data_list.append(
{
"id": i.id,
"company_name": i.company_name,
"name": i.name,
#"product": i.product,
#"industry": i.industry,
#"invest": i.invest,
#"section": i.section,
"stage": i.stage,
"unit":i.unit,
"link": i.link,
#"status": status_list[int(status)]
}
)
data = {"data_list": data_list, "maxnum": maxnum}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 招商资源管理
# 新增项目详情页的下拉列表
@api_mobile.route("/mobileUpList", methods=["GET"])
# @login_required
def mobile_up_list():
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
user_id = 3
try:
user = User.query.get(user_id)
role = user.flag
if role != 2:
return jsonify(code=RET.ROLEERR, msg="无权限查看此内容")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
try:
attract = Attract.query.filter_by(statu=1)
industry_list = attract.filter_by(sid=1).all()
stage_list = attract.filter_by(sid=2).all() # 项目阶段
unit = Government.query.filter_by().all()
industry = [{"name": i.name, "indu_id": i.nid} for i in industry_list] # 项目行业
industry = [{"name": "请选择", "indu_id": ""}] + industry
stage = [{"name": i.name, "stage_id": i.nid} for i in stage_list] # 项目阶段
stage = [{"name": "请选择", "stage_id": ""}] + stage
unit = [{"name": i.name, "unit_id": i.id} for i in unit] # 报送单位
unit = [{"name": "请选择", "unit_id": ""}] + unit
invest = [{"invest": "请选择", "invest_id": ""}, {"invest": "1亿元以下", "invest_id": 1},
{"invest": "1-10亿", "invest_id": 2},
{"invest": "10-50亿", "invest_id": 3}, {"invest": "50-100亿", "invest_id": 4},
{"invest": "100亿以上", "invest_id": 5}] # 投资额
data = {
"industry": industry,
"stage": stage,
"unit": unit,
"invest": invest
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
@api_mobile.route("/mobileUpItem", methods=["POST"])
@login_required
def mobile_up_item():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
role = user.flag
if role != 2:
return jsonify(code=RET.ROLEERR, msg="无权限查看此内容")
unit = user.unit
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
#user_id = 3
req_dic = request.get_json()
indu_id = req_dic.get("indu_id") # 行业，
invest_id = req_dic.get("invest_id") # 投资额ID
evolve_id = req_dic.get("stage_id") # 项目进度
unit_name = req_dic.get("unit") # 报送单位
way_id = req_dic.get("way_id") # 查看方式
search = req_dic.get("search") # 搜索框
order = str(req_dic.get("order")) # 顺序 1-正序，2-倒序
page = req_dic.get("page") # 页数
perpage = req_dic.get("perpage") # 每页个数
if search:
try:
user = User.query.get(user_id)
b = []
if user.searchitem:
for j in user.searchitem:
b.append(j.history)
if search in b:
user.searchitem.remove(user.searchitem[b.index(search)])
if len(b) > 5:
user.searchitem.remove(user.searchitem[0])
sear = SearchItem(history=search)
db.session.add(sear)
user.searchitem.append(sear)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg='数据库错误')
try:
item = Item.query.filter_by(unit_up=unit)
if not page:
page = 1
if not perpage:
perpage = 10
if indu_id:
item = item.filter_by(indu_id=indu_id)
if invest_id:
item = item.filter_by(invest_id=invest_id)
if evolve_id:
item = item.filter_by(stage_id=evolve_id)
if unit_name:
if unit_name != "请选择":
item = item.filter_by(unit=unit_name)
# 进行中项目
if way_id == 1:
# 数据可能需要改
item = item.filter(and_(Item.stage_id != 5, Item.stage_id != 10))
# 投促局调度的项目
if way_id == 2:
item = item.filter_by(belong=1)
# 搜索，模糊查询
if search:
item = item.filter(or_(Item.company_name.like('%' + search + "%"), Item.name.like('%' + search + "%")))
# 排序
item = item.order_by(desc(Item.id))
if order:
if order == "2":
item = item.order_by(desc(Item.invest))
else:
item = item.order_by(Item.invest)
maxnum = len(item.all())
item = item.paginate(page, perpage).items
except Exception as e:
current_app.logger.error(e)
return jsonify(code = RET.DBERR,msg = "数据库错误")
# for j in government_list:
# new_item = item.filter_by(unit_up = j.name).order_by(desc(Item.id)).all()
#status_list = ["", "未上报", "已上报", "已驳回", "已通过"]
data_list = []
for i in item:
# status = i.status
# if not i.status:
# status = 0
data_list.append({
"item_id":i.id,
"name": i.name,
"company": i.company_name,
#"product": i.product,
#"industry": i.industry,
#"invest": i.invest,
"stage": i.stage,
"unit": i.unit,
"link": i.link,
#"status":status_list[int(status)]
})
data = {"data_list": data_list, "maxnum": maxnum}
return jsonify(code=RET.OK, msg="查找成功", data=data)
@api_mobile.route("/mobiledetailsItem", methods=["POST"])
@login_required
def mobile_details_item():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
# user_id = 3
try:
user = User.query.get(user_id)
role = user.flag
if role != 2:
return jsonify(code=RET.ROLEERR, msg="无权限查看此内容")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
req_dic = request.get_json()
item_id = req_dic.get("item_id")
if not item_id:
return jsonify(code=RET.DATAERR, msg="缺少必要的参数")
try:
item = Item.query.get(item_id)
if not item:
return jsonify(code=RET.DATAERR, msg="不存在这样的项目")
data = {
"build_date": item.build_date.strftime('%Y-%m-%d'),
"company_name": item.company_name,
"admin": item.admin,
"mobile": item.mobile,
"email": item.email,
"name": item.name,
"store": item.store.strftime('%Y-%m-%d'),
"product": item.product,
"industry": item.industry,
"invest": item.invest,
"area": item.area,
"value": item.value,
"tax": item.tax,
"unit":item.unit,
"link": item.link,
"link_mobile": item.link_mobile,
"email": item.email,
# "level": item.level,
# "stage": item.stage,
"main_introduce": item.main_introduce if item.main_introduce else "-",
"invest_introduce": item.invest_introduce if item.invest_introduce else "-",
"build_introduce": item.build_introduce if item.build_introduce else "-",
"encomy": item.encomy if item.encomy else "-",
"policy": item.policy if item.policy else "-",
"question": item.question if item.question else "-",
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
#搜索历史接口
@api_mobile.route("/mobileSearchItem",methods = ["GET"])
@login_required
def mobile_search_item():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
data = {
"search":[i.history for i in user.searchitem]
}
data["search"] = data["search"][::-1]
return jsonify(code = RET.OK,msg = "查询成功",data = data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
#搜索历史接口
@api_mobile.route("/deleteSearchItem",methods = ["GET"])
@login_required
def delete_search_item():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
for i in user.searchitem:
user.searchitem.remove(i)
db.session.commit()
return jsonify(code = RET.OK,msg = "删除成功")
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 获取机构的部门和人员
@api_mobile.route("/getSectionPeople", methods=["GET"])
# @login_required
def get_section_people():
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
user_id = 3
try:
user = User.query.get(user_id)
unit = user.unit
government = Government.query.filter_by(name = unit).first()
data = []
for i in government.sections:
person = [{"name":"请选择","id":""}]
section = User.query.filter(and_(User.unit == government.name,
User.section == i.name,User.id != user_id)).all()
for j in section:
person.append({"name": j.name, "id": j.id})
data.append({"person": person, "name": i.name, "section_id": i.id})
data = [{"section_id":"","name":"请选择","person":[{"name":"请选择","id":""}]}] + data
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
#机构统筹的机构
@api_mobile.route("/UnitUnit",methods = ["GET"])
# @login_required
def unit_unit():
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
user_id = 3
try:
user = User.query.get(user_id)
unit_name = user.unit
unit = Government.query.filter_by(name = unit_name).first()
data = [{"name":i.name,"unit_id":i.id}for i in unit.followed]
data = [{"name":"请选择","unit_id":""}] + data
return jsonify(code = RET.OK,msg = "查找成功",data = data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code = RET.DBERR,msg = "数据库错误")
# 招商进度管理统计图查看（机构内部）
@api_mobile.route("/stageInTable", methods=["POST"])
# @login_required
def stage_in_table():
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
user_id = 3
try:
user = User.query.get(user_id)
role = user.flag
if role != 2:
return jsonify(code=RET.ROLEERR, msg="无权限查看此内容")
unit = user.unit
_section = user.section
role = user.role.role
except Exception as e:
current_app.logger.error(e)
return jsonify(code = RET.DBERR,msg = "数据库错误")
req_dic = request.get_json()
year_begin = req_dic.get("year_begin")
month_begin = req_dic.get("month_begin")
year_end = req_dic.get("year_end")
month_end = req_dic.get("month_end")
stage_id = req_dic.get("stage_id")
indu_id = req_dic.get("indu_id")
section = req_dic.get("section")
user_id = req_dic.get("user_id")
if not all([year_begin, month_begin, year_end, month_end]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
year_begin = year_begin[:-1]
month_begin = month_begin[:-1]
(year_end, month_end) = get_year_month(year_end[:-1], month_end[:-1])
date_begin = time.strptime("{}-{}-01".format(year_begin,month_begin), '%Y-%m-%d')
date_end = time.strptime("{}-{}-01".format(year_end,month_end), '%Y-%m-%d') # - relativedelta(months=-1)
try:
if role[0] == "1":
item = Item.query.filter(and_(Item.unit == unit, Item.store >= date_begin, Item.store < date_end))
if role[0] == "2":
item = Item.query.filter(and_(Item.unit == unit,Item.section == _section, Item.store >= date_begin, Item.store < date_end))
if role[0] == "3":
item = Item.query.filter(and_(Item.user_id == user_id, Item.store >= date_begin, Item.store < date_end))
item_user = User.query.filter_by(unit = unit)
item_evolve = Attract.query.filter_by(statu = 1,sid = 2)
item_industry = Attract.query.filter_by(statu = 1,sid = 1)
if stage_id:
item = item.filter_by(stage_id=stage_id)
item_evolve = Attract.query.filter_by(nid = stage_id)
if indu_id:
item = item.filter_by(industry=indu_id)
item_industry = item_industry.filter_by(nid = indu_id)
if section:
if section != "请选择":
item = item.filter_by(section=section)
item_user = item_user.filter_by(section = section)
if user_id:
item = item.filter_by(user_id=user_id)
item_user = item_user.filter_by(section=section,id = user_id)
item_evolve = set(item_evolve.with_entities(Attract.nid).all())
item_evolve = list(item_evolve)
item_evolve.sort()
stage = [{
"name": Attract.query.filter_by(nid=i[0],sid = 2).first().name,"value" :item.filter_by(stage_id=i[0]).count()
} for i in item_evolve]
item_user = set(item_user.with_entities(User.id).all())
user = [{
"name":User.query.get(i[0]).real_name,"value":item.filter_by(user_id=i[0]).count(),
} for i in item_user]
item_industry = set(item_industry.with_entities(Attract.nid).all())
industry = [{
"name" :Attract.query.filter_by(nid=i[0], sid=1).first().name,"value": item.filter_by(indu_id=i[0]).count()
} for i in item_industry]
data = {
"stage": stage,
"user": user,
"industry": industry
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 招商进度管理统计图查看（机构统筹机构）
@api_mobile.route("/stageOutTable", methods=["POST"])
@login_required
def stage_out_table():
token = request.headers["token"]
user = verify_token(token)
user_id = user.id
try:
user = User.query.get(user_id)
unit = user.unit
role = user.flag
if role != 2:
return jsonify(code=RET.ROLEERR, msg="无权限查看此内容")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
req_dic = request.get_json()
year_begin = req_dic.get("year_begin")
month_begin = req_dic.get("month_begin")
year_end = req_dic.get("year_end")
month_end = req_dic.get("month_end")
unit_name = req_dic.get("unit_name")
stage_id = req_dic.get("stage_id")
indu_id = req_dic.get("indu_id")
if not all([year_begin, month_begin, year_end, month_end]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
year_begin = year_begin[:-1]
month_begin = month_begin[:-1]
(year_end, month_end) = get_year_month(year_end[:-1], month_end[:-1])
date_begin = time.strptime("{}-{}-01".format(year_begin, month_begin), '%Y-%m-%d')
date_end = time.strptime("{}-{}-01".format(year_end, month_end), '%Y-%m-%d') # - relativedelta(months=-1)
try:
item = Item.query.filter(and_(Item.store >= date_begin, Item.store < date_end,Item.unit_up == unit))
government = Government.query.filter_by(name=unit).first()
foller_name = [i.name for i in government.followed]
item = item.filter(Item.unit.in_(foller_name))
item_user = item.filter(Item.unit.in_(foller_name))
item_evolve = Attract.query.filter_by(statu=1, sid=2)
item_industry = Attract.query.filter_by(statu=1, sid=1)
if stage_id:
item = item.filter_by(stage_id=stage_id)
item_evolve = Attract.query.filter_by(nid=stage_id)
if indu_id:
item = item.filter_by(industry=indu_id)
item_industry = item_industry.filter_by(nid=indu_id)
if unit_name:
if unit_name != "请选择":
item = item.filter_by(unit=unit_name)
item_user = item_user.filter_by(unit=unit_name)
item_evolve = set(item_evolve.filter_by(statu = 1,sid = 2).with_entities(Attract.nid).all())
item_evolve = list(item_evolve)
item_evolve.sort()
stage = [{
"name":Attract.query.filter_by(nid=i[0],sid = 2).first().name,"value":item.filter_by(stage_id=i[0]).count()
} for i in item_evolve]
item_user = set(item_user.with_entities(Item.unit).all())
unit = [{
"name":i[0],"value": item.filter_by(unit=i[0]).count()
} for i in item_user]
item_industry = set(item_industry.with_entities(Attract.nid).all())
industry = [{
"name":Attract.query.filter_by(nid=i[0], sid=1).first().name,"value": item.filter_by(indu_id=i[0]).count()
} for i in item_industry]
data = {
"stage": stage,
"unit": unit,
"industry": industry
}
return jsonify(code=RET.OK, msg="查找成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
apps/view_mobile/view_atlas.py 0 → 100644
from flask import current_app, request, jsonify
from apps.view_mobile import api_mobile
from sqlalchemy import extract, or_, and_
from sqlalchemy.sql import func
from apps.models import *
from apps.util import login_required, verify_token
from apps.utils.response_code import RET
from datetime import datetime, timedelta
import datetime
# 太原市企业列表
@api_mobile.route('/tycompany', methods=['POST'])
@login_required
def enterprise():
'''太原市企业列表'''
# 获取用户id
token = request.headers["token"]
user = verify_token(token)
user_id = user.id # 用户id
# user_id = 5 # 用户id
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
entype = req_dict.get("entype") # 企业类型id
qualificat = req_dict.get("qualificat") # 企业资质id
capital = req_dict.get("capital") # 注册资本id
quoted = req_dict.get("quoted") # 上市板块
district = req_dict.get("district") # 太原市下区县
yearid = req_dict.get("yearid") # 成立时间年限id
roundid = req_dict.get("roundid") # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if cate == "1":
company = Company.query.filter_by(f_type=inid, city="太原市")
else:
company = Company.query.filter_by(c_type=inid, city="太原市")
# 企业类型
if entype:
company = company.filter_by(entypeid=entype)
# 企业资质
if qualificat:
if qualificat == 1:
company = company.filter_by(high_new=1)
if qualificat == 2:
company = company.filter_by(tbe=1)
if qualificat == 3:
company = company.filter_by(quoted_company=1)
if qualificat == 4:
company = company.filter_by(sxonhun=1)
if qualificat == 5:
company = company.filter_by(isfive=1)
if qualificat == 6:
company = company.filter_by(unicorn=1)
if qualificat == 7:
company = company.filter_by(dengl=1)
if qualificat == 8:
company = company.filter_by(zjtg=1)
if qualificat == 9:
company = company.filter_by(scale=1)
if qualificat == 10:
company = company.filter_by(serve=1)
# 注册资本
if capital:
company = company.filter_by(capital_id=capital)
# 上市板块
if quoted:
company = company.filter_by(public_id=quoted)
# 区域选择
if district:
company = company.filter_by(district=district)
# 成立时间id
if yearid:
company = company.filter_by(yearid=yearid)
# 融资轮次
if roundid:
company = company.filter_by(roundid=roundid)
size = company.count()
companys = company.order_by(Company.hots.desc()).paginate(page, perpage).items # 企业热度倒序
user = User.query.get(user_id) # 获取关注列表
if user:
company_ids = [coms.id for coms in user.company]
else:
company_ids = []
df = [{"id": com.id,
"company_name": com.company_name,
"legal": com.legal if com.legal else "",
"capital": com.capital if com.capital else "",
"build_date": str(com.build_date)[:10] if com.build_date else "",
"collect": "1" if com.id in company_ids else "2", # 关注状态码1关注，2未关注
"choice": "1" # 1太原企业，2全国企业
} for com in companys]
data = {"size": size, "df": df}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="参数错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# 全国企业列表
@api_mobile.route('/attract/enterprise', methods=['POST'])
# @login_required
def att_enterprise():
'''
太原市企业列表
:return:
'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
entype = req_dict.get("entype") # 企业类型id
qualificat = req_dict.get("qualificat") # 企业资质id
capital = req_dict.get("capital") # 注册资本id
quoted = req_dict.get("quoted") # 上市板块
area = req_dict.get("area") # ["省","市","区"]
province = area[0]
city = area[1]
district = area[2]
yearid = req_dict.get("yearid") # 成立时间年限id
roundid = req_dict.get("roundid") # 融资轮次id(天使/种子，1)（PreA/A+,2）（PreB/B+,3）(C轮以上，4)（收并购，5）（战略投资，6）（其他，7）
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid: # 子行业分类
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
# 企业类型
if entype:
enterprise = enterprise.filter_by(entypeid=entype)
# 企业资质
if qualificat:
if qualificat == 1:
enterprise = enterprise.filter_by(high_new=1)
if qualificat == 2:
enterprise = enterprise.filter_by(tbe=1)
if qualificat == 3:
enterprise = enterprise.filter_by(quoted_company=1)
if qualificat == 4:
enterprise = enterprise.filter_by(isfive=1)
if qualificat == 5:
enterprise = enterprise.filter_by(unicorn=1)
if qualificat == 6:
enterprise = enterprise.filter_by(dengl=1)
# 注册资本
if capital:
enterprise = enterprise.filter_by(capital_id=capital)
# 上市板块
if quoted:
enterprise = enterprise.filter_by(public_id=quoted)
# 区域选择
if province:
enterprise = enterprise.filter_by(province=province)
if city:
enterprise = enterprise.filter_by(city=city)
if district:
enterprise = enterprise.filter_by(district=district)
# 成立时间id
if yearid:
enterprise = enterprise.filter_by(yearid=yearid)
# 融资轮次
if roundid:
enterprise = enterprise.filter_by(roundid=roundid)
size = enterprise.count()
enterprise = enterprise.order_by(Enterprise.hots.desc()).paginate(page, perpage).items # 企业热度倒序
df = [{"id": com.id,
"company_name": com.company_name, # 企业名称
"status": com.status if com.status else "", # 企业状态
"legal": com.legal if com.legal else "", # 法人
"capital": com.capital if com.capital else "", # 注册资本
"build_date": str(com.build_date)[:10] if com.build_date else "", # 时间
"telephone": str(com.telephone) if com.telephone else "", # 电话
"address": str(com.address) if com.address else "", # 地址
"lng":com.lng if com.lng else "",
"lat":com.lat if com.lat else "",
# "collect": "1" if com.id in company_ids else "2", # 关注状态码1关注，2未关注
"choice": "2" # 1太原企业，2全国企业
} for com in enterprise]
data = {"size": size, "df": df}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
# ty+全国企业信息详情
@api_mobile.route('/companyDetail', methods=['POST'])
@login_required
def company_detail():
'''
企业信息详情
:return:
'''
# 获取用户id
token = request.headers["token"]
user = verify_token(token)
user_id = user.id # 用户id
# user_id = 5
req_dict = request.get_json()
_id = req_dict.get("id") # 企业id
choice = req_dict.get("choice") # 企业选择
# 校验参数完整性
if not all([_id, choice]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if choice == "1":
company = Company.query.get(_id)
user = User.query.get(user_id) # 获取关注列表
if user:
company_ids = [coms.id for coms in user.company]
else:
company_ids = []
if company:
data = {"id": company.id,
"company_name": company.company_name,
"legal": company.legal if company.legal else "", # 法人
"status": company.status if company.status else "", # 状态
"build_date": str(company.build_date)[:10] if company.build_date else "", # 成立日期
"capital": company.capital if company.capital else "", # 注册资本
"telephone": company.telephone if company.telephone else "", # 电话
"address": company.address if company.address else "", # 地址
"email": company.email if company.email else "-", # 邮箱
# "web_site": company.web_site if company.web_site else "-", # 网址
"company_info": company.company_info if company.company_info else "", # 简介
"social_code": company.social_code if company.social_code else "", # 社会统一信用代码
"tax_code": company.tax_code if company.tax_code else "", # 纳税人识别号
"register_code": company.register_code if company.register_code else "", # 注册号
"company_code": company.company_code if company.company_code else "", # 组织机构代码
"bao": company.bao_num if company.bao_num else 0, # 组织机构代码
"entype": company.entype if company.entype else "", # 企业类型
"industry": company.company_industry if company.company_industry else "", # 所属行业
"scope": company.business_scope if company.business_scope else "", # 经营范围
"taking": company.takingn if company.takingn else "", # 营收
"jwd": {"lng": company.lng if company.lng else "-",
"lat": company.lat if company.lat else "-"},
# "high_new": "高新技术企业" if company.high_new else "-",
"collect": "1" if company.id in company_ids else "2", # 关注状态码1关注，2未关注
"choice": "1" # 1太原企业，2全国企业
}
else:
return jsonify(code=RET.NODATA, msg="查无数据")
return jsonify(code=RET.OK, msg="获取成功", data=data)
else:
enterprise = Enterprise.query.get(_id)
user = User.query.get(user_id) # 获取关注列表
if user:
company_ids = [coms.id for coms in user.enterprise]
else:
company_ids = []
if enterprise:
data = {"id": enterprise.id,
"company_name": enterprise.company_name,
"legal": enterprise.legal if enterprise.legal else "", # 法人
"status": enterprise.status if enterprise.status else "", # 状态
"build_date": str(enterprise.build_date)[:10] if enterprise.build_date else "", # 成立日期
"capital": enterprise.capital if enterprise.capital else "", # 注册资本
"telephone": enterprise.telephone if enterprise.telephone else "", # 电话
"address": enterprise.address if enterprise.address else "", # 地址
"email": enterprise.email if enterprise.email else "-", # 邮箱
# "web_site": company.web_site if company.web_site else "-", # 网址
"company_info": enterprise.company_info if enterprise.company_info else "", # 简介
"social_code": enterprise.social_code if enterprise.social_code else "", # 社会统一信用代码
"tax_code": enterprise.tax_code if enterprise.tax_code else "", # 纳税人识别号
"register_code": enterprise.register_code if enterprise.register_code else "", # 注册号
"company_code": enterprise.company_code if enterprise.company_code else "", # 组织机构代码
"bao": enterprise.bao_num if enterprise.bao_num else 0, # 组织机构代码
"entype": enterprise.entype if enterprise.entype else "", # 企业类型
"industry": enterprise.company_industry if enterprise.company_industry else "", # 所属行业
"scope": enterprise.business_scope if enterprise.business_scope else "", # 经营范围
"taking": enterprise.takingn if enterprise.takingn else "", # 营收
"jwd": {"lng": enterprise.lng if enterprise.lng else "-",
"lat": enterprise.lat if enterprise.lat else "-"},
# "high_new": "高新技术企业" if company.high_new else "-",
"collect": "1" if enterprise.id in company_ids else "2", # 关注状态码1关注，2未关注
"choice": "2" # 1太原企业，2全国企业
}
else:
return jsonify(code=RET.NODATA, msg="查无数据")
return jsonify(code=RET.OK, msg="获取成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
# 太原市创新资源机构列表（高等院校和告高职转告合并，高职专高作为第二分类，合并两个表）
@api_mobile.route('/innovate/orgs', methods=['POST'])
# @login_required
def orgs():
'''创新资源机构列表'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
cateone = req_dict.get("cateone") # 机构类型id. 高等院校1,科研机构2，创新平台3，产业服务平台4
catetwo = req_dict.get("catetwo") # 机构类型2 id
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
# 校验参数完整性
if not all([cateone, page, perpage]):
return jsonify(code=RET.PARAMERR, msg="创新资源机构一类参数不完整")
if (inid and not cate) or (cate and not inid):
return jsonify(code=RET.PARAMERR, msg="行业参数不完整")
# if cate and not inid:
# return jsonify(code=RET.PARAMERR, msg="行业参数不完整")
if cateone == 1: # 高等院校
try:
if inid:
name = Industry.query.filter_by(nid=inid).first().oname
if cate == "1":
college = College.query.filter(College.navigator.like("%{}%".format(name)))
else:
college = College.query.filter(College.navigat.like("%{}%".format(name)))
else:
college = College.query.filter_by()
if catetwo:
college = college.filter_by(cateid=catetwo)
size = college.count()
college = college.paginate(page, perpage).items
data = {"df": [{"id": i.id,
"name": i.name,
"nature": i.nature if i.nature else "-", # 办学性质
"build_date": i.buildate if i.buildate else "-", # 时间
"clas": i.clas if i.clas else "-", # 类别
"cateone": cateone} for i in college],
"size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DATAERR, msg="参数错误")
elif cateone == 2: # 科研机构
if inid:
name = Industry.query.filter_by(nid=inid).first().oname
if cate == "1":
scientific = Scientific.query.filter(Scientific.navigator.like("%{}%".format(name)))
else:
scientific = Scientific.query.filter(Scientific.navigat.like("%{}%".format(name)))
else:
scientific = Scientific.query.filter_by()
size = scientific.count()
scientific = scientific.paginate(page, perpage).items
data = {"df": [{"id": i.id,
"name": i.name,
"telephone": str(i.telephone) if i.telephone else "-", # 电话
"address": i.address if i.address else "-", # 地址
"cateone": cateone} for i in scientific],
"size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
elif cateone == 3: # 创新平台3
if inid:
name = Industry.query.filter_by(nid=inid).first().oname
if cate == "1":
lab = Lab.query.filter(Lab.navigator.like("%{}%".format(name)))
else:
lab = Lab.query.filter(Lab.navigat.like("%{}%".format(name)))
else:
lab = Lab.query.filter_by()
if catetwo:
lab = lab.filter_by(cateid=catetwo)
size = lab.count()
lab = lab.paginate(page, perpage).items
data = {"df": [{"id": i.id,
"name": i.name,
# "cate": i.cate,
"address": i.address if i.address else "-", # 地址
"cateone": cateone} for i in lab],
"size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
elif cateone == 4: # 产业服务平台
if inid:
name = Industry.query.filter_by(nid=inid).first().oname
if cate == "1":
platform = Platform.query.filter(Platform.navigator.like("%{}%".format(name)))
else:
platform = Platform.query.filter(Platform.navigat.like("%{}%".format(name)))
else:
platform = Platform.query.filter_by()
if catetwo:
platform = platform.filter_by(cateid=catetwo)
size = platform.count()
platform = platform.paginate(page, perpage).items
data = {"df": [{"id": i.id,
"name": i.name,
# "cate": cateone,
"address": i.address if i.address else "-", # 地址
"cateone": cateone} for i in platform],
"size": size}
return jsonify(code=RET.OK, msg="查询成功", data=data)
else:
return jsonify(code=RET.PARAMERR, msg="参数错误")
# 太原园区列表
@api_mobile.route('/carrier/garden', methods=['POST'])
# @login_required
def garden():
'''创新资源机构列表'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
cate = req_dict.get("cate") # 行业等级,（高端设备等五个为"1",子行业为"2"）
page = req_dict.get("page") # 分页页码
perpage = req_dict.get("perpage") # 分页大小
keyword = req_dict.get("keyword") # 搜索园区姓名
level = req_dict.get("level") # 园区级别
# 校验参数完整性
if not all([page, perpage]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid:
name = Industry.query.filter_by(nid=inid).first().oname # 获取导航对应的真名
if cate == "1":
induzone = Induzone.query.filter(Induzone.navigator.like("%{}%".format(name)))
else:
induzone = Induzone.query.filter(Induzone.navigat.like("%{}%".format(name)))
else:
induzone = Induzone.query.filter_by()
if keyword:
induzone = induzone.filter(Induzone.name.like("%{}%".format(keyword))) # 查询词
if level:
induzone = induzone.filter_by(level=level) # 园区级别筛选
size = induzone.count() # 分页总数
induzone = induzone.paginate(page, perpage).items
data = {"garden": [{"id": i.id,
"name": i.name,
"level": i.level if i.level else "-", # 级别
# "cate": i.cate, # 园区类型
"area": i.area if i.area else "-", # 面基
"cluster": i.cluster if i.cluster else "" # 集群
} for i in induzone],
"size": size}
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="查询成功", data=data)
# 雷达监测页企业数量趋势统计
@api_mobile.route('/radar/tendency', methods=['POST'])
@login_required
def tendency():
'''雷达监测页企业数量统计'''
req_dict = request.get_json()
inid = req_dict.get("inid") # 行业id
area = req_dict.get("area") # [省，市，区]
province = area[0]
city = area[1]
district = area[2]
product = req_dict.get("product") # 企业产品
sone = req_dict.get("sone") # 选择1，1企业个数，2注册资本
stwo = req_dict.get("stwo") # 选择2， 1年度，2季度，3月度
sthr = req_dict.get("sthr") # 选择3， 1新增量，2累积量
# 校验参数完整性
if not all([area, sone, stwo, sthr]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
if inid:
enterprise = Enterprise.query.filter_by(c_type=inid)
else:
enterprise = Enterprise.query.filter_by()
if province:
enterprise = enterprise.filter_by(province=province)
if city:
enterprise = enterprise.filter_by(city=city)
if district:
enterprise = enterprise.filter_by(district=district)
if product:
# 有可能会变成模糊查询
enterprise = enterprise.filter(Enterprise.product_all.like("%{}%".format(product)))
# company = company.filter_by(product_all=product)
yearn = datetime.datetime.now().year + 1 # 现在年份
scope = [i for i in range(1980, yearn, 5)] # 年份范围
months = [(1, 3), (4, 6), (7, 9), (10, 12)] # 季度
data = list()
if sthr == 1: # 新增量
if stwo == 1: # 年度，1980-2020
for year in scope:
result = enterprise.filter(extract("year", Enterprise.build_date) == year)
if sone == 1: # 企业个数
nums = result.count()
# data[year] = nums
data.append({"lable": year, "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[year] = round(cnums, 2) if cnums else 0
data.append({"lable": year, "value": round(cnums, 2) if cnums else 0})
elif stwo == 2: # 2020年季度
for jd in range(len(months)):
result = enterprise.filter(and_(extract("year", Enterprise.build_date) == (yearn - 1),
extract("month", Enterprise.build_date).between(months[jd][0],
months[jd][1])))
if sone == 1: # 企业个数
nums = result.count()
# data[(jd + 1)] = nums
data.append({"lable": (jd + 1), "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[(jd + 1)] = round(cnums, 2) if cnums else 0
data.append({"lable": (jd + 1), "value": round(cnums, 2) if cnums else 0})
elif stwo == 3: # 2020年月度
for m in range(1, 13):
result = enterprise.filter(and_(extract("year", Enterprise.build_date) == (yearn - 1),
extract("month", Enterprise.build_date) == m))
if sone == 1: # 企业个数
nums = result.count()
# data[m] = nums
data.append({"lable": m, "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[m] = round(cnums, 2) if cnums else 0
data.append({"lable": m, "value": round(cnums, 2) if cnums else 0})
elif sthr == 2: # 累积量
if stwo == 1: # 年度，1980-2020
for year in scope:
result = enterprise.filter(extract("year", Enterprise.build_date) <= year)
if sone == 1: # 企业个数
nums = result.count()
# data[year] = nums
data.append({"lable": year, "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[year] = round(cnums, 2) if cnums else 0
data.append({"lable": year, "value": round(cnums, 2) if cnums else 0})
elif stwo == 2: # 2020年季度
for jd in range(len(months)):
result = enterprise.filter(and_(extract("year", Enterprise.build_date) == (yearn - 1),
extract("month", Enterprise.build_date) <= months[jd][1]))
if sone == 1: # 企业个数
nums = result.count()
# data[(jd + 1)] = nums
data.append({"lable": (jd + 1), "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
# data[(jd + 1)] = round(cnums, 2) if cnums else 0
data.append({"lable": (jd + 1), "value": round(cnums, 2) if cnums else 0})
elif stwo == 3: # 2020年月度
for m in range(1, 13):
result = enterprise.filter(and_(extract("year", Enterprise.build_date) == (yearn - 1),
extract("month", Enterprise.build_date) <= m))
if sone == 1: # 企业个数
nums = result.count()
# data[m] = nums
data.append({"lable": m, "value": nums})
else: # 注册资本
cnums = result.with_entities(func.sum(Enterprise.capital_nums)).scalar()
data.append({"lable": m, "value": round(cnums, 2) if cnums else 0})
# data[m] = round(cnums, 2) if cnums else 0
else:
return jsonify(code=RET.DATAERR, msg="参数错误")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库查询错误")
return jsonify(code=RET.OK, msg="获取成功", data=data)
apps/view_mobile/view_user.py 0 → 100644
from flask import current_app, request, jsonify
from apps.view_mobile import api_mobile
from sqlalchemy import extract, or_, and_
from sqlalchemy.sql import func
from apps.models import *
from apps.util import login_required, verify_token
from apps.utils.response_code import RET
from datetime import datetime, timedelta
import re
from apps import db, constants, redis_store
# 手机端个人中心信息获取
@api_mobile.route('/userInfo', methods=['GET'])
@login_required
def user_info():
# 获取用户id
token = request.headers["token"]
user = verify_token(token)
user_id = user.id # 用户id
# user_id = 5 # 用户id
try:
user = User.query.get(user_id)
if user:
data = {"id": user.id,
"name": user.name if user.name else "-", # 用户名
"mobile": user.mobile, # 手机号
"unit": user.unit if user.unit else "", # 机构
"section": user.section if user.section else "", # 部门
"position": user.position if user.position else "", # 职务
"sex": user.sex if user.sex else "", # 性别，1男2女
"email": user.email if user.email else "" # 邮箱
}
return jsonify(code=RET.OK, msg="查询成功", data=data)
return jsonify(code=RET.NODATA, msg="无法获取信息")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="参数错误")
# 手机端个人中心用户名修改
@api_mobile.route('/editName', methods=['POST'])
# @login_required
def edit_name():
# 获取用户id
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id # 用户id
# user_id = 5 # 用户id
req_dict = request.get_json()
uname = req_dict.get("uname") # 用户名
user_id = req_dict.get("id") # 用户id
# 校验参数完整性
if not all([uname]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 用户名唯一(字母开头，长度4-15)
try:
patten = "^[a-zA-Z][\w]*[\w]*$"
if re.match(patten, uname) and re.match(patten, uname).string == uname:
user = User.query.filter_by(name=uname).filter(User.id != user_id).first()
if user:
return jsonify(code=RET.DATAEXIST, msg="用户名已存在")
else:
return jsonify(code=RET.DATAERR, msg="用户名格式错误,字母开头")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="用户名格式错误")
try:
user = User.query.get(user_id)
user.name = uname
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="参数错误")
# 修改手机号
@api_mobile.route("/editPhone", methods=["POST"])
# @login_required
def edit_phone():
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id
# user_id = 5
req_dict = request.get_json()
user_id = req_dict.get("user_id")
mobile = req_dict.get("mobile")
sms_code = req_dict.get("sms_code")
# 校验参数完整性
if not all([mobile, mobile]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
# 校验手机号格式
if not re.match(r'^1[3456789]\d{9}$', mobile):
return jsonify(code=RET.PARAMERR, msg="手机号格式错误")
# 判断短信验证码是否失效
if not redis_store:
return jsonify(code=RET.NODATA, msg="短信验证码失效")
# 获取短信验证码
try:
real_sms_code = redis_store.get('sms_code_{}'.format(mobile)).decode()
# real_sms_code = "123456"
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="redis数据库异常")
# 判断用户填写短信验证码是否一致
if real_sms_code != sms_code:
# if "123456" != sms_code:
return jsonify(code=RET.DATAERR, msg="短信验证码错误")
# 删除redis中的短信验证码，防止重复校验
try:
redis_store.delete("sms_code_{}".format(mobile))
except Exception as e:
current_app.logger.error(e)
# 获取用户
try:
user = User.query.filter_by(mobile=mobile).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="获取用户信息失败")
if user:
return jsonify(code=RET.DATAEXIST, msg="手机号已被注册")
# 修改手机号
try:
user = User.query.get(user_id)
user.mobile = mobile
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="数据库错误")
# 手机端个人中心性别修改
@api_mobile.route('/editSex', methods=['POST'])
# @login_required
def edit_sex():
# 获取用户id
# token = request.headers["token"]
# user = verify_token(token)
# user_id = user.id # 用户id
# user_id = 5 # 用户id
req_dict = request.get_json()
user_id = req_dict.get("id") # 用户id
sex = req_dict.get("sex") # 男1女2
# 校验参数完整性
if not all([sex]):
return jsonify(code=RET.PARAMERR, msg="参数不完整")
try:
user = User.query.get(user_id)
user.sex = sex
db.session.commit()
return jsonify(code=RET.OK, msg="修改成功")
except Exception as e:
current_app.logger.error(e)
return jsonify(code=RET.DBERR, msg="参数错误")
config.py 0 → 100644
# import os
import redis
import datetime
from urllib import parse
# 将开发模式和调试模式的配置信息中相同的部分复用
class Config:
# sql数据库
# 在连接前将特殊的密码转码再链接即可
passowrd = parse.quote_plus('Root@2020')
SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:{}@rm-8vbn50m65w332c23aso.mysql.zhangbei.rds.aliyuncs.com/jincheng_data?charset=utf8mb4".format(passowrd) # 晋城 阿里云
# SQLALCHEMY_DATABASE_URI = '{}+{}://{}:{}@{}:{}/{}?charset=utf8'.format(
# 'mysql', 'pymysql', 'root', 'Root@2020', 'rm-8vbn50m65w332c23aso.mysql.zhangbei.rds.aliyuncs.com', '3306', 'jincheng_data'
# )
SQLALCHEMY_TRACK_MODIFICATIONS = False
# redis配置信息
REDIS_HOST = '127.0.0.1'
REDIS_PORT = 6379
# REDIS_PASS = "Mypwdty2020!" # TODO
REDIS_PASS = None # TODO
# # ---------------七牛云存储------------------
# QINIU_ACCESS_KEY = '' # AK
# QINIU_SECRET_KEY = '' # SK
# QINIU_BUCKET_NAME = '' # 空间名
# QINIU_BUCKET_DOMAIN = '' # 外链域名
# ---------------session-------------------
SECRET_KEY = 'WER43TTHYUIP0-[-;IJTRGWFE3EWDAFG*(&REF343'
TOKEN_EXPIRATION = 43200
# 保存到session中值的前缀
SESSION_KEY_PREFIX = 'session'
# session配置存储到redis中
SESSION_TYPE = 'redis'
SESSION_REDIS = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASS)
SESSION_USE_SIGNER = True
# 对session_id进行隐藏处理
# PREMANENT_SESSION_LIFETIME = 60 # 整数表示秒
# 设置session的有效时间
# PREMANENT_SESSION_LIFETIME = datetime.timedelta(hours=1)
PREMANENT_SESSION_LIFETIME = datetime.timedelta(days=1)
# 请求内容最大长度(上传文件大小控制16M)
MAX_CONTENT_LENGTH = 16 * 1024 * 1024
# -----------邮箱--------------
MAIL_SERVER = 'smtp.163.com'
MAIL_PORT = 465 # 邮箱服务器端口
MAIL_USE_SSL = True
MAIL_USE_TLS = False
MAIL_USERNAME = 'a289237642@163.com'
MAIL_PASSWORD = 'a289237642'
MAIL_DEFAULT_SENDER = 'a289237642@163.com'
# 邮箱的安全协议（Gmail是TLS，qq和一些别的是SSL）
class DevelopmentConfig(Config):
'''开发模式配置信息'''
DEBUG = True
class ProductionConfig(Config):
'''生产环境配置信息'''
pass
config_map = {
'develop': DevelopmentConfig,
# 'product': ProductionConfig,
}
\ No newline at end of file
manager.py 0 → 100644
from flask import Flask
from apps import creat_app, db
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand
from apps.models import *
app = creat_app('develop')
# app = creat_app('product')
manager = Manager(app)
Migrate(app, db)
manager.add_command('db', MigrateCommand)
'''
python manager.py db init 初始化迁移文件
python manager.py db migrate 生成模型迁移文件
python manager.py db upgrade 将迁移文件映射到数据库中
'''
if __name__ == '__main__':
manager.run()
requirement.txt 0 → 100644
alembic==1.3.2
alibabacloud-credentials==0.1.4
alibabacloud-endpoint-util==0.0.3
alibabacloud-openapi-util==0.1.4
alibabacloud-tea==0.2.6
alibabacloud-tea-openapi==0.2.5
alibabacloud-tea-util==0.3.4
alibabacloud-vod20170321==2.0.2
aliyun-python-sdk-core==2.13.31
aliyun-python-sdk-core-v3==2.13.11
aliyun-python-sdk-dysmsapi==1.0.0
aliyun-python-sdk-vod==2.15.12
asn1crypto==0.24.0
attrs==19.1.0
Automat==0.7.0
blinker==1.4
boto==2.49.0
boto3==1.12.39
botocore==1.15.39
cachelib==0.1.1
certifi==2019.11.28
cffi==1.12.3
chardet==3.0.4
Click==7.0
constantly==15.1.0
cryptography==3.4.7
cssselect==1.1.0
docker==4.4.4
docutils==0.15.2
elasticsearch==7.12.0
english==2020.7.0
filetype==1.0.7
Flask==1.1.1
Flask-Cors==3.0.10
Flask-Mail==0.9.1
Flask-Migrate==2.7.0
Flask-QiniuStorage==0.9.5
Flask-Script==2.0.6
Flask-Session==0.3.2
Flask-SQLAlchemy==2.5.1
Flask-WTF==0.14.3
hyperlink==19.0.0
idna==2.8
incremental==17.5.0
itsdangerous==1.1.0
Jinja2==2.10.1
jmespath==0.9.5
lazy-object-proxy==1.4.2
lxml==4.4.2
Mako==1.1.0
MarkupSafe==1.1.1
monotonic==1.5
neotime==1.7.4
numpy==1.18.0
packaging==20.9
pandas==1.1.0
pansi==2020.7.3
parsel==1.5.2
prompt-toolkit==2.0.10
py2neo==4.3.0
pyasn1==0.4.7
pyasn1-modules==0.2.6
pycparser==2.19
PyDispatcher==2.0.5
Pygments==2.3.1
PyHamcrest==1.9.0
PyMySQL==1.0.2
pyOpenSSL==19.0.0
pyparsing==2.4.7
python-dateutil==2.8.1
python-editor==1.0.4
pytz==2019.2
pywin32==227
qiniu==7.3.0
queuelib==1.5.0
redis==3.3.8
requests==2.22.0
s3transfer==0.3.3
scipy==1.4.1
Scrapy==1.7.3
service-identity==18.1.0
six==1.15.0
smart-open==1.11.1
soupsieve==1.9.5
SQLAlchemy==1.3.12
sqlparse==0.3.0
Twisted==19.7.0
typed-ast==1.4.0
urllib3==1.24.3
w3lib==1.21.0
wcwidth==0.1.7
websocket-client==0.58.0
Werkzeug==0.16.0
wrapt==1.11.2
WTForms==2.3.3
xlrd==1.2.0
XlsxWriter==1.3.8
xlwt==1.3.0
zope.interface==4.6.0
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment