def handler(self, *args, **kwargs):
try:
func(self, *args, **kwargs)
except Exception, e:
result = utils.init_response_data()
result = utils.reset_response_data(0, str(e))
self.finish(result)
def put(self):
result = utils.init_response_data()
try:
banner_id = self.get_argument("banner_id", "")
use_type = self.get_argument("use_type", "banner")
banner = self.model.get_coll().find_one({"_id": utils.create_objectid(banner_id), "enable_flag": 1})
if banner is None:
raise ValueError(u'该图片不存在或已被删除')
files = self.request.files
if files.has_key("files"):
files = files["files"]
data = self.model.upload_image(files, use_type)
else:
raise ValueError(u"没有上传文件")
for d in data:
banner["file_name"] = d["file_name"]
banner["use_type"] = d["use_type"]
banner["add_time"] = d["add_time"]
banner["file_type"] = d["file_type"]
banner["logs"].append({
"user_id": "",
"action_date": utils.get_current_time(),
"action": "修改文件",
"note": "file_path|from|%s|to|%s" % (banner['file_path'], d['file_path'])
})
banner["file_path"] = d["file_path"]
self.model.get_coll().save(banner)
except StandardError, e:
result = utils.reset_response_data(0, unicode(e))
def post(self):
result = utils.init_response_data()
self.model.extra_params = self.response_extra_params
try:
self.check_request_params(self.mp_require_params)
request_params = self.format_request_params()
exec("""request_params = self.mp_default_params.update(%s)""" %
request_params)
request_params = self.mp_default_params
query_params = {}
for key in self.mp_query_params:
query_params.update({
key: request_params[key],
})
if query_params == {} or not self.model.is_exists(query_params):
obj = self.model.create(**request_params)
result["data"] = utils.dump(obj)
else:
if self.mp_update_or_raise == "update":
obj = self.model.search(query_params)
query_params = {"_id": utils.create_objectid(obj["_id"])}
result["data"] = self.model.update(query_params,
request_params)
else:
raise Exception("已存在！")
except Exception, e:
result = utils.reset_response_data(0, str(e))
def get(self):
result = utils.init_response_data()
self.model.extra_params = self.response_extra_params
try:
page = self.get_argument("page", 1)
page_size = self.get_argument("page_size", 10)
time_desc = self.get_argument("time_desc", "all")
start_time = self.get_argument("start_time", None)
end_time = self.get_argument("end_time", None)
if time_desc != "all":
start_time, end_time = self._get_search_time(
time_desc, start_time, end_time)
self.mg_query_params.update(
{"add_time": {
"$gte": start_time,
"$lte": end_time,
}})
objs, pager = self.model.search_list(
page=page,
page_size=page_size,
query_params=self.mg_query_params)
result["data"] = objs
result["pager"] = pager
except Exception, e:
result = utils.reset_response_data(0, str(e))
self.finish(result)
return
def delete(self):
result = utils.init_response_data()
try:
ids = json.loads(self.get_argument("ids"))
_ids = [utils.create_objectid(id) for id in ids]
for _id in _ids:
self.model.delete(_id=_id)
except Exception, e:
result = utils.reset_response_data(0, str(e))
def get(self):
try:
obj_list, pager = self.model.search_list(
query_params=self.mg_query_params, pager_flag=False)
namelist = self.namelist
column_list = self.column_list
if len(namelist) != len(column_list) + 1:
raise Exception("namelist and column_list 长度不一致")
elif len(column_list) == 0 and len(namelist) == 1:
if len(obj_list) > 0:
obj = obj_list[0]
namelist = self.namelist + obj.keys()
column_list = obj.keys()
curr_time = str(datetime.datetime.now())
report_china_name = "%s%s" % (self.report_name,
curr_time.replace(".", "-").replace(
" ", "-").replace(":", "-"))
format_column_list = ["%s:None" % column for column in column_list]
column_dict = {}
map(
lambda x: column_dict.setdefault(
x.split(':')[0],
x.split(':')[1]), format_column_list)
temp_column_dict = column_dict
export_list = []
for obj in obj_list:
for column in column_list:
if obj.has_key(column):
temp_column_dict[column] = obj[column]
else:
try:
temp_column_dict[column] = getattr(
self.model, "get_%s" % column)(obj)
except:
temp_column_dict[column] = ""
export_list.append(copy.copy(temp_column_dict))
temp_column_dict = column_dict
if len(export_list) > 0:
fieldlist = column_list
else:
fieldlist = []
result = reportlib.export_excel(
report_china_name=[report_china_name],
namelist=[namelist],
result=[export_list],
fieldlist=[fieldlist],
)
file_names = result['filename']
file_paths = result["file_path"]
report_data = result["report_data"]
except Exception, e:
result = utils.reset_response_data(0, str(e))
self.write(result)
self.finish()
return
def delete(self):
result = utils.init_response_data()
banner_model_obj = self.model.BannerModel()
try:
banner_id = self.get_argument("banner_id", "")
banner_model_obj.delete(banner_id)
result["data"] = "success"
except StandardError, e:
result = utils.reset_response_data(0, unicode(e))
def post(self):
result = utils.init_response_data()
checkcode_coll = self.model.get_coll()
try:
phone = self.get_argument("phone", "")
phone_code = self.get_argument("phone_code", "")
if phone != "":
utils.check_code(checkcode_coll, phone, phone_code)
except Exception, e:
result = utils.reset_response_data(0, str(e))
def get(self):
result = utils.init_response_data()
self.model.extra_params = self.mg_extra_params
try:
id = self.get_argument("id")
_id = utils.create_objectid(id)
ret = self.model.search({"_id": _id})
if ret:
result["data"] = ret
else:
result["data"] = {}
except Exception, e:
result = utils.reset_response_data(0, str(e))
def get(self):
result = utils.init_response_data()
try:
keyword = self.get_argument("keyword", "")
if keyword != "":
self.mg_query_params.update({"name": {"$regex": keyword}})
self.mg_sort_params = {
"city": -1,
}
except Exception, e:
result = utils.reset_response_data(0, str(e))
self.write(result)
self.finish()
return
def post(self):
try:
result = utils.init_response_data()
client = tornado.httpclient.AsyncHTTPClient()
response = yield tornado.gen.Task(
client.fetch, "http://120.26.226.63:20000/works")
response_body = json.loads(response.body)
data = response_body.get("data", {})
works = data.get("works", [])
t_s = open(
os.path.dirname(options.root_path) + "/var/mail/工作日报.xls", "r")
t_s_data = t_s.read()
t_s.close()
to_email = ["*****@*****.**"]
for work in works:
filename = os.path.dirname(options.root_path) + "/var/mail/工作日报%s.xls"%( str(datetime.datetime.now()).\
replace(".","_").replace(":","_").replace(" ","_") )
w_d = open(filename, "w")
w_d.write(t_s_data)
w_d.close()
copy_data = [
(4, 1, work.get("name", "")),
(4, 2, work.get("hr_analytic_timesheet_id")[1]),
]
curr_time = datetime.datetime.now()
title = "东汇集团胜众科技有限公司征信项目组%s%s年%s月%s日工作日报" % (
work.get("user_id")[1], curr_time.year, curr_time.month,
curr_time.day)
reportlib.copy_xls(filename, title, data=copy_data)
attachments = []
attachments.append(dict(
filename=u"工作日报.xls",
data=filename,
))
from_email = "*****@*****.**"
send_email(from_email,
to_email,
"工作日报",
'',
html='',
attachments=attachments)
result["data"] = works
except Exception, e:
result = utils.reset_response_data(0, str(e))
self.write(result)
self.finish()
return
def get(self):
result = utils.init_response_data()
checkcode_coll = self.model.get_coll()
try:
mobile = self.get_argument("mobile")
yield async_server.cmd(self.model.check_mobile, mobile)
yield self.executor.submit(self.model.check_limit, (mobile))
random_code = utils.get_random_num(6, mode="number")
yield async_server.cmd(self.model.send_kaixintong_sms, mobile,
random_code)
yield self.model.save(mobile, random_code, result)
result["data"]["code"] = random_code
except Exception, e:
result = utils.reset_response_data(0, str(e))
def post(self):
result = utils.init_response_data()
try:
request_files = self.request.files
if request_files.has_key("files"):
files = request_files["files"]
data = self.model.upload_image(files,file_type=0)
else:
raise ValueError(u"没有上传文件")
for d in data:
self.model.create(**d)
except Exception,e:
result = utils.reset_response_data(0, unicode(e))
def get(self):
result = utils.init_response_data()
try:
client = tornado.httpclient.AsyncHTTPClient()
response = yield tornado.gen.Task(
client.fetch, "http://221.226.241.45:8889/worksheet/members")
response_body = json.loads(response.body)
data = response_body.get("data", [])
members = data.get("member_list", [])
result["data"] = members
except Exception, e:
result = utils.reset_response_data(0, str(e))
self.write(result)
self.finish()
return
def get(self):
result = utils.init_response_data()
checkcode_coll = self.model.get_coll()
try:
mobile = self.get_argument("mobile")
curr_time = datetime.datetime.now()
if checkcode_coll.find({
"mobile": mobile,
"enable_flag": True
}).count() > 0:
# 验证码请求限制 每小时限制5条
if checkcode_coll.find({
"mobile": mobile,
"add_time": {
"$gte": curr_time - datetime.timedelta(hours=1),
"$lte": curr_time + datetime.timedelta(hours=1),
}
}).count() >= 5:
raise Exception("验证码请求限制，每小时限制5条！")
cr = checkcode_coll.find({
"mobile": mobile,
"enable_flag": True
})
for checkcode in cr:
checkcode["enable_flag"] = False
checkcode_coll.save(checkcode)
else:
pass
random_code = utils.get_random_num(6, mode="number")
checkcode_coll.insert_one({
"mobile": mobile,
"enable_flag": True,
"add_time": curr_time,
"type": "mobile",
"code": random_code,
})
# res = wslib.send_msg(mobile,"尊敬的用户您好，您本次的验证码为%s,30分钟内有效"%random_code)
# if res != "0" :
# raise ValueError(u"短信发送失败")
result["data"]["code"] = random_code
except Exception, e:
result = utils.reset_response_data(0, str(e))
def get(self):
result = utils.init_response_data()
try:
_id = self.get_argument("_id")
link = self.model.search({"_id": utils.create_objectid(_id)})
if link:
count = link.get("count", 0) + 1
last_read_time = str(datetime.datetime.now())
query_params = {"_id": utils.create_objectid(_id)}
update_params = {
"count": count,
"last_read_time": last_read_time
}
self.model.update(query_params, update_params)
except Exception, e:
result = utils.reset_response_data(0, str(e))
self.write(result)
self.finish()
return
def put(self):
result = utils.init_response_data()
try:
id = self.get_argument("id")
_id = utils.create_objectid(id)
self.check_request_params(self.mp_require_params)
request_params = self.format_request_params()
update_params = {}
exec("""update_params.update(%s)""" % request_params)
self.check_update_params(update_params)
update_params["_id"] = _id
del update_params["id"]
ret = self.model.update(query_params={"_id": _id},
update_params=update_params)
result['data'] = ret
except Exception, e:
result = utils.reset_response_data(0, str(e))
def get(self):
result = utils.init_response_data()
try:
client = tornado.httpclient.AsyncHTTPClient()
response = yield tornado.gen.Task(
client.fetch, "http://221.226.241.45:8889/worksheet/projects")
response_body = json.loads(response.body)
data = response_body.get("data", [])
projects = data.get("projects", [])
result["data"] = []
for project in projects:
result["data"].append(
dict(
title=project.get("name", ""),
id=project.get("id", 0),
tasks=project.get("task_list", []),
))
except Exception, e:
result = utils.reset_response_data(0, str(e))
self.write(result)
self.finish()
return
def post(self):
try:
result = utils.init_response_data()
client = tornado.httpclient.AsyncHTTPClient()
response = yield tornado.gen.Task(
client.fetch, "http://120.26.226.63:20000/works")
response_body = json.loads(response.body)
data = response_body.get("data", {})
works = data.get("works", [])
curr_time = str(datetime.datetime.now()).split(" ")[0]
start_time = curr_time + " " + "00:00:00.000"
end_time = curr_time + " " + "23:59:59.999"
result["data"] = []
for work in works:
username = work.get("user_id")[1]
obj = self.model.coll.find_one({
"name": username,
"add_time": {
"$gte": start_time,
"$lte": end_time,
},
})
if obj:
continue
else:
obj = {}
obj["name"] = username
obj["work"] = work.get("name", "")
obj["work_desc"] = work.get("hr_analytic_timesheet_id")[1]
self.model.create(**obj)
result["data"].append(obj)
except Exception, e:
result = utils.reset_response_data(0, str(e))
self.write(result)
self.finish()
return
def post(self):
result = utils.init_response_data()
try:
to_mail_list = json.loads(self.get_argument("to_mail_list", "[]"))
theme = self.get_argument("theme", "工作日报")
template = self.get_argument("template", "default")
template_args = json.loads(self.get_argument(
"template_args", "{}"))
content = self.generate(template, template_args)
attachments = []
request_files = self.request.files
if request_files.has_key("files"):
files = request_files["files"]
for file in files:
filename = file.get("filename", "")
temp_filename_path = os.path.dirname(options.root_path).encode("utf-8") + u"/var/mail/" + filename + u"_" +\
str(datetime.datetime.now()).replace(".","_").replace(":","_").replace(" ","_") + ".xls"
temp_mail_file = open(temp_filename_path, "w")
temp_mail_file.write(file.get("body", ""))
attachments.append(
dict(
filename=u"工作日报.xls",
data=temp_filename_path,
))
print attachments
send_email('*****@*****.**',
to_mail_list,
theme,
'',
html=content,
attachments=attachments)
except Exception, e:
result = utils.reset_response_data(0, str(e))
self.write(result)
self.finish()
return
def prepare(self):
try:
token = self.get_argument('access_token', None)
if not token:
auth_header = self.request.headers.get('Authorization', None)
if not auth_header:
raise Exception('This resource need a authorization token')
token = auth_header[7:]
key = 'oauth2_{}'.format(token)
access = self.provider["provider"].access_token_store.rs.get(key)
if access:
access = json.loads(access.decode())
else:
raise Exception('Invalid Token')
if access['expires_at'] <= int(time.time()):
raise Exception('expired token')
authority = importlib.import_module("dxb.authority").authority
authority.process(self.request, access)
except Exception as err:
self.set_header('Content-Type', 'application/json')
self.set_status(401)
result = utils.reset_response_data(0, str(err))
self.finish(result, status_code=401)
