Skip to content

M
mancheng
Commit dcddd7c9 by root
Options

招商驾驶舱

parents
Showing with 2755 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/attract/__init__.py 0 → 100644
from flask import Blueprint
# 创建蓝图对象
api_att = Blueprint("api_att", __name__)
from . import view
'''招商地图页'''
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/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/models.py 0 → 100644
This diff is collapsed. Click to expand it.
apps/radar/__init__.py 0 → 100644
from flask import Blueprint
# 创建蓝图对象
api_radar = Blueprint("api_radar", __name__)
from . import view
'''招商雷达'''
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/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_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_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_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/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