def _handle_request(self):
body = {}
if self.parse_from_body:
try:
body = json.loads(request.data)
# 统一打印下请求参数
for key, value in body.iteritems():
if key == "common_param":
self.common_param = value
self.os = self.common_param["device_type"]
self.app_version = self.common_param["app_version"]
self.cuid = self.common_param["cuid"] # 游客id
self.user_id = self.common_param["user_id"] # 用户id
logger.debug(body)
except Exception, ex:
logger.error("[%s] request.body not json str, ex: %s",
self.trace_id,
ex,
exc_info=1)
self.ret_code = errcode.JSON_BODY_DECODE_ERROR
self.ret_msg = "request.body not json str"
return False
def get_action_code(self):
if not self.check_input_arguments(["phone"]):
return self._response(error_msg.PARAMS_ERROR)
code = "".join([str(random.randint(0, 9)) for i in range(4)])
url = "https://api.miaodiyun.com/20150822/industrySMS/sendSMS"
try:
m = hashlib.md5()
sid = "4bb28e9c0f194975bfe28214941690bd"
token = "be9da0e2c8d04b5c86c9a105ac6e4a5d"
ts = datetime.datetime.now().strftime("%Y%m%d%H%m%s")
m.update("{0}{1}{2}".format(sid, token, ts).encode('utf-8'))
sig = m.hexdigest()
payload = {
"accountSid": sid,
"sig": sig,
"timestamp": ts,
"templateid": settings.TEMPLATEID,
"param": code,
"to": self._input["phone"]
}
r = requests.post(url, data=payload)
if r.json().get("respCode", "1") == "00000":
return self._response(data=int(code))
return self._response(error_msg.PHONE_NUMBER_ERROR)
except Exception as e:
logger.error("requets miaodiyun error {0}".format(e))
return self._response(error_msg.SERVER_ERROR)
def _check_sid(self):
"""
校验每一个请求的sid，后台服务，就是通过sid来控制整个app的生命账户的生命周期！！
:return:
"""
# 检查接口是否允许空字符串的sid，如登录、注册、忘记密码等可以允许空字符串
if self.sid_control_level == constant.SID_CAN_BE_NULL:
logger.info("sid can be null...")
return True
# 调试模式，可以不带sid
if config.debug_mode == 1:
try:
logger.info("调试模式开启，不检查sid!")
sid = self.common_param["sid"]
sid_info = sid_manager.SidManager.sid2info(sid)
if sid_info:
self.uid = sid_info.userid # 这个是医生、用户的id，可能是游客id
self.user_type = sid_info.user_type # 这个是用户类型，0-游客，1-用户，2-医生
else:
self.uid = 0
self.user_type = 0
return True
except Exception, ex:
logger.error(ex, exc_info=1)
self.ret_code = errcode.SID_NOT_CORRECT
self.ret_msg = "common_param sid not correct..."
logger.error("common_param sid not correct...")
return False
def do_filter(self, **kwargs):
session = kwargs.get("session", None)
if session is None:
return None
pk = kwargs.get("id", None)
try:
filter_obj = session.query(self._model)
if pk is not None:
return filter_obj.filter_by(id=pk)
value = {
k: self._clean_value(kwargs[k])
for k in self._filter_value(kwargs)
}
filter_obj = filter_obj.filter_by(**value)
kv = kwargs.get("like", None)
if kv is not None:
k, v = kv.split("^")
filter_obj = filter_obj.filter(
getattr(self._model, k).like("%%%s%%" % v))
id_list = kwargs.get("id_list", None)
if id_list is not None:
filter_obj = filter_obj.filter(
getattr(self._model, "id").in_(id_list))
filter_condition = kwargs.get('filter_condition', None)
if filter_condition is not None:
filter_obj = filter_obj.filter(filter_condition)
return filter_obj
except Exception as e:
logger.error(u"查询%s出错. %s, %s" %
(self._model.__tablename__, e, kwargs))
return None
def keys(self, pattern='*'):
try:
return self.r.keys(pattern)
except Exception, ex:
logger.error(ex, exc_info=1)
self.is_w_working = False
return None
def insert(cls, _dic):
"""
插入Something...
:param _dic: 新增的字典
:return:
"""
key_value_lst = []
for key, value in _dic.items():
# 普通字符串
if type(value) == str or type(value) == unicode:
value = _mysql.escape_string(value)
item = "'%s'" % value
else:
item = "%s" % value
key_value_lst.append(item)
sql = "insert into {db}.{tbl}({column_list}) values ({value_list})". \
format(db=cls.db_name,
tbl=cls.table_name,
column_list=','.join(["`%s`" % v for v in _dic.keys()]),
value_list=','.join(key_value_lst))
logger.info("base_insert===> %s" % sql)
if cls.db_name == db_name_config.DOCTOR_DB:
ret = doctor_conn.execute_with_exception(sql)
elif cls.db_name == db_name_config.DOCTOR_USER_DB:
ret = doctor_user_conn.execute_with_exception(sql)
elif cls.db_name == db_name_config.DOCTOR_QUESTION_DB:
ret = doctor_question_conn.execute_with_exception(sql)
else:
logger.error("error db...")
ret = None
return ret
def _wrap_items(self, _items):
"""
精简返回值
:param _items:
:return:
"""
for item in _items:
if "id" in item:
del item["id"]
if "obj_id" in item:
del item["obj_id"]
if "ui_type" in item:
del item["ui_type"]
# 解析desc
if "desc" in item:
if "{" in item["desc"]:
try:
item["desc"] = json.loads(item["desc"])
except Exception, ex:
logger.error(ex, exc_info=1)
item["desc"] = {}
if "[" in item["desc"]:
try:
item["desc"] = json.loads(item["desc"])
except Exception, ex:
logger.error(ex, exc_info=1)
item["desc"] = []
def sid2info(cls, sid):
"""
SID ==> INFO对象
"%s|%s|%s|%s|%s|%s" % (
self.user_type, self.userid, self.version, self.timestamp, self.device_type, self.cuid)
:param sid:
:return:
"""
try:
if not sid:
logger.info("sid -> info: sid is null.")
return None
if config.SID_ENCRYPT_KEY: # 加密
sid = base64.b64decode(sid)
sid = MyDESCryptUtil.decrypt(sid)
values = sid.split('|')
if len(values) < 6:
logger.info("sid -> info: sid trans error...")
return None
sid_info = SidInfo(*values)
if sid_info.is_expired():
logger.info("SID=%s 过期" % sid_info.to_string())
return None
return sid_info
except Exception, ex:
logger.error("sid -> info失败：%s" % str(ex), exc_info=1)
logger.error(sid)
return None
def _parse_and_check_parameters(self):
"""
1、解析参数 -> self.para_map中。
2、检验参数是否正确？是否必传的参数没有传？
:return: True, False
"""
body = json.loads(request.data)
for key, default_value in self.expected_para.iteritems():
value = body.get(key, default_value)
if isinstance(value, unicode):
value = value.encode("utf-8")
self.para_map[key] = value
if request.cookies:
for key, default_value in self.expected_para.iteritems():
value = request.cookies.get(key, default_value)
if value != default_value:
self.para_map[key] = value
for key in self.required_para:
if self.para_map[key] is None:
logger.error("request param is blank：%s" % key)
self.ret_code = errcode.PARAM_REQUIRED_IS_BLANK
self.ret_msg = "request param is blank"
return False
return True
def scan_iter(self, match=None, count=None):
try:
return self.r.scan_iter(match, count)
except Exception, ex:
self.is_r_working = False
logger.error("redis r connect error:%s", str(ex))
return None
def exists(self, name):
try:
return self.r.exists(name)
except Exception, ex:
logger.error(ex, exc_info=1)
self.is_w_working = False
return None
def check_r_conn(self):
try:
r_connecting = self.r.ping()
self.is_r_working = r_connecting
except Exception, ex:
self.is_r_working = False
logger.error("redis r connect error:%s", str(ex))
def get(self, key):
try:
ret_v = self.r.get(key)
return ret_v
except Exception, ex:
self.is_r_working = False
logger.error("redis r connect error:%s", str(ex))
def post_action_decode_tx(self):
if not self.check_input_arguments(["tx_hex"]):
return self._response(error_msg.PARAMS_ERROR)
url = "https://live.blockcypher.com/btc/decodetx/"
try:
r = requests.post(
url,
data={
"tx_hex": self._input["tx_hex"],
"coin_symbol": "btc",
"csrfmiddlewaretoken": "0x7JG1aNt03Ovn4vPL7wz05s8F8DtUDq"
},
cookies={"csrftoken": "0x7JG1aNt03Ovn4vPL7wz05s8F8DtUDq"})
find_key = "<pre><small>"
s = r.text.find(find_key)
if s == -1:
return self._response(error_msg.PARAMS_ERROR)
else:
e = r.text.find("</small>", s)
result = r.text[s + len(find_key):e].replace("\n", "")
self._data = json.loads(result)
return self._response()
except Exception as e:
logger.error("decode tx_hex http error {0}".format(e))
return self._response(error_msg.SERVER_ERROR)
def hexists(self, name, key):
"Returns a boolean indicating if ``key`` exists within hash ``name``"
try:
return self.r.hexists(name, key)
except Exception, ex:
logger.error(ex, exc_info=1)
self.is_w_working = False
return None
def _do_put(self):
try:
if self._controller_obj.update_item(**self._input):
return True
else:
return False
except Exception as e:
logger.error("put method error: %s" % e)
return False
def get_action_fee(self):
url = "https://bitcoinfees.earn.com/api/v1/fees/list"
try:
r = requests.get(url).json().get("fees", [])
for i in r:
if int(i["memCount"]) < 50 and int(i["dayCount"] > 1000):
return self._response(data=i["minFee"])
except Exception as e:
logger.error("fee error", e)
return self._response(data=15)
def get_action_block(self):
url = "{}/latestblock".format(self.URL)
try:
r = requests.get(url).json()
height = r.get("height", 0)
except Exception as e:
logger.error("requests lateblock error{}".format(e))
return self._response(error_msg.SERVER_ERROR)
self._data = height
return self._response()
def post_action_broadcast(self):
if not self.check_input_arguments(["tx_hex"]):
return self._response(error_msg.PARAMS_ERROR)
try:
NetworkAPI.broadcast_tx(self._input.get("tx_hex", None))
except Exception as e:
logger.error("broadcast_tx error tx:{0}. error:{1}".format(
self._input.get("tx_hex"), e))
return self._response(error_msg.SERVER_ERROR)
return self._response()
def _do_delete(self):
try:
if self._controller_obj.delete_item(**self._input):
return True
else:
logger.error("delete method error")
return False
except Exception as e:
logger.error("delete method error: %s" % e)
return False
def get_model_pk(self):
"""
获取model主键
:return: Column
"""
try:
ins = inspect(self._model)
return ins.primary_key[0]
except Exception as e:
logger.error("获取主键失败e" % e)
return None
def _do_post(self):
try:
if self._controller_obj.new_item(**self._input):
return True
else:
logger.error("post method error")
return False
except Exception as e:
self._ret, self._msg = error_msg.SERVER_ERROR
logger.error("post method error: %s" % e)
return False
def filter_item(self, **kwargs):
session = kwargs.get("session", None)
if session is None:
return None, None
start = int(kwargs.get("start", -1))
end = int(kwargs.get("end", -1))
compare_key = kwargs.get("compare_key", None)
gte = kwargs.get("gte", None)
gt = kwargs.get("gt", None)
lte = kwargs.get("lte", None)
lt = kwargs.get("lt", None)
pk = kwargs.get("id", None)
try:
filter_obj = self.do_filter(**kwargs)
if not filter_obj:
return None, None
if compare_key and hasattr(self._model, compare_key):
if gte:
filter_obj = filter_obj.filter(
getattr(self._model, compare_key) >= gte)
if gt:
filter_obj = filter_obj.filter(
getattr(self._model, compare_key) > gt)
if lte:
filter_obj = filter_obj.filter(
getattr(self._model, compare_key) <= lte)
if lt:
filter_obj = filter_obj.filter(
getattr(self._model, compare_key) < lt)
if pk:
return filter_obj.first(), 1
order_by = kwargs.get("order_by", None)
order_method = kwargs.get("order_method", None)
if order_by is None:
filter_obj = filter_obj.order_by(desc("id"))
else:
if order_method == "desc":
filter_obj = filter_obj.order_by(desc(order_by))
else:
filter_obj = filter_obj.order_by(order_by)
if start == -1 and end == -1:
data = filter_obj.all()
return data, len(data)
else:
pk = self.get_model_pk()
if pk is None:
return None, None
return filter_obj[start:end], filter_obj.with_entities(
func.count(pk)).scalar()
except Exception as e:
logger.error(u"查询%s出错. %s, %s" %
(self._model.__tablename__, e, kwargs))
return None, None
def info2sid(cls, sid_info):
'''SidInfo -> SID'''
if not sid_info:
return ""
try:
if config.SID_ENCRYPT_KEY:
_str = MyDESCryptUtil.encrypt(sid_info.to_string())
return base64.b64encode(_str)
return sid_info.to_string()
except Exception, ex:
logger.error("info -> sid失败:%s" % str(ex), exc_info=1)
return ""
def update(cls, dic, where_col='id', where_col_str=False):
"""
更新Something...
:param dic: 字典
:return:
"""
key_value_lst = []
for key, value in dic.items():
logger.info("%s=%s" % (key, value))
if key == where_col:
continue
# 普通字符串
if type(value) == str or type(value) == unicode:
value = _mysql.escape_string(value)
item = "%s='%s'" % (key, value)
# 需要追加的int，比如 like_num: (1, True)，那么是like_num = like_num + 1
elif type(value) == tuple and len(value) == 2:
if value[1]:
item = "%s=%s+%s" % (key, key, value[0])
else:
item = "%s=%s" % (key, value[0])
# 普通int， 比如 del_flag: 1, 直接 def_flag = 1
else:
item = "%s=%s" % (key, value)
key_value_lst.append(item)
sql = "update {db}.{tbl} set ".format(db=cls.db_name,
tbl=cls.table_name)
sql += ",".join(key_value_lst)
# where 列默认是id
where_value = dic[where_col]
if where_col_str:
sql += " where %s = '%s'" % (where_col, where_value)
else:
sql += ' where %s = %s' % (where_col, where_value)
logger.info("base_update: %s" % sql)
if cls.db_name == db_name_config.DOCTOR_DB:
ret = doctor_conn.execute_with_exception(sql)
elif cls.db_name == db_name_config.DOCTOR_USER_DB:
ret = doctor_user_conn.execute_with_exception(sql)
elif cls.db_name == db_name_config.DOCTOR_QUESTION_DB:
ret = doctor_question_conn.execute_with_exception(sql)
else:
logger.error("error db...")
ret = None
return ret
def get_by_location_and_section(cls, province_code, city_code, area_code,
section_outer, section_inner, page_num,
page_size):
"""
分页获取...
:return:
"""
# 省市区
location_str = ""
if province_code != 0 and city_code == 0 and area_code == 0:
location_str = " and province={province} ".format(
province=province_code)
elif province_code != 0 and city_code != 0 and area_code == 0:
location_str = " and province={province} and city={city} ". \
format(province=province_code,
city=city_code)
elif province_code != 0 and city_code != 0 and area_code != 0:
location_str = " and province={province} and city={city} and area={area} ". \
format(province=province_code,
city=city_code,
area=area_code)
# 科室
section_str = ""
if section_outer and section_inner:
section_str = " and section_p='{section_outer}' and section_c='{section_inner}' ". \
format(section_outer=section_outer,
section_inner=section_inner
)
elif section_outer and not section_inner:
section_str = " and section_p='{section_outer}' ". \
format(section_outer=section_outer,
)
# 分页
offset = (page_num - 1) * page_size
sql = "select * from {db}.{table} where del_flag=0 " \
"{location_str} {section_str} " \
"limit {offset},{limit}". \
format(db=cls.db_name,
table=cls.table_name,
offset=offset,
limit=page_size,
location_str=location_str,
section_str=section_str,
)
logger.error(sql)
item_list = doctor_conn.fetchall(sql)
return item_list
def _do_get(self, disable_output=None, transform_json=True):
try:
data, total = self._controller_obj.filter_item(**self._input)
self._data["total"] = total
if transform_json:
self._data["list"] = utility.to_obj(
data, without_fields=disable_output)
else:
self._data["list"] = data
return True
except Exception as e:
traceback.print_exc()
logger.error("get method error: %s" % e)
return False
def delete_item(self, **kwargs):
session = kwargs.get("session", None)
if session is None:
return False
try:
filter_obj = self.do_filter(**kwargs)
if filter_obj:
filter_obj.delete()
return True
else:
return False
except Exception as e:
logger.error(u"删除%s出错. %s, %s" %
(self._model.__tablename__, e, kwargs))
return False
def post(self):
self.request = request
logger.debug("[%s ###### START]", self.trace_id)
ret = self._handle_request()
if ret is False:
return self._handle_return()
# 在最上层处理异常
try:
self._version_control()
self._process_imp()
except Exception, ex:
logger.error(ex, exc_info=1)
self.ret_code = errcode.DB_OPERATION_ERROR
self.ret_msg = "operation error"
def _handle_request(self):
body = {}
if self.parse_from_body:
try:
body = json.loads(request.data)
# 统一打印下请求参数
for key, value in body.iteritems():
if key == "common_param":
self.common_param = value
self.os = self.common_param["device_type"]
self.app_version = self.common_param["app_version"]
self.cuid = self.common_param["cuid"] # 游客id
self.user_id = self.common_param["user_id"] # 用户id
# tid 游客(tourist) id
# rid 注册用户(registed user) id
self.tid = self.common_param[
"tid"] if "tid" in self.common_param else 0
self.rid = self.common_param[
"rid"] if "rid" in self.common_param else 0
# 用户类型
self.user_type = constant.USER_SOURCE_UNKNOWN
if self.tid > 0:
self.user_type = constant.USER_SOURCE_TOURIST
if self.rid > 0:
self.user_type = constant.USER_SOURCE_LOGIN_USER
# 摇摆用户变量, 要么是tid，要么是rid
if self.user_type == constant.USER_SOURCE_LOGIN_USER:
self.swing_id = self.rid
elif self.user_type == constant.USER_SOURCE_TOURIST:
self.swing_id = self.tid
else:
self.swing_id = 0
logger.debug(body)
except Exception, ex:
logger.error("[%s] request.body not json str, ex: %s",
self.trace_id,
ex,
exc_info=1)
self.ret_code = errcode.JSON_BODY_DECODE_ERROR
self.ret_msg = "request.body not json str"
return False
