class BaseHandler(web.RequestHandler):
log = app_log
executor = futures.ThreadPoolExecutor(8)
def set_default_headers(self):
self.set_header("Content-Type", "application/json;charset:utf-8")
def __init__(self, filename=None):
self.filename = filename
self.io_loop = ioloop.IOLoop.current()
self.executor = futures.ThreadPoolExecutor(8)
if self.filename and os.path.exists(filename):
db = json.load(open(filename, 'r'))
self.collections = db['collections']
else:
self.collections = {'maxid': 0}
def setUpClass(cls):
cls.paypal_client = PayPalClient(
mode='sandbox',
client_id=
'AduMrSVpBpufHUUZN_PNzRf5kBCSBxOKPlFYHDjSv9EbxPrRwXgMmbyaIpA1r5U2bixBi2XtZ7rtNPdU',
client_secret=
'EMqbZ1SvnbGRGBMK-SvvEEW4oT9B_0BdOzerpLUKVUcqGSEqfc-edoBP7RwKnzuBlLr-whyDU2EpTTQH'
)
cls.executor = futures.ThreadPoolExecutor()
cls.async_do = cls.executor.submit
def __init__(self, meta_data, branch='master'):
self.io_loop = ioloop.IOLoop.current()
self.executor = futures.ThreadPoolExecutor(8)
self.meta = meta_data
self.branch = branch
self._users = set()
self._id = self.meta['id']
self._full_id = ProjectFactory._full_id(self.meta['id'], branch)
self._repo = repo(os.path.join(conf.workdirs, self._id),
self.branch,
clone_url=self.meta['repo_url'],
branch=self.branch)
self._wd = os.path.join(conf.workdirs, self._id, self.branch)
class UploadHandler(BaseHandler):
executor = futures.ThreadPoolExecutor(100)
@run_on_executor()
def save_file(self,
fileobj,
base_dir,
filename=None,
user=None,
is_image=True):
if not user:
user = "******"
upload_path = user + "/" + datetime.datetime.utcnow().strftime(
"%Y%m%d") + "/"
# 安全过滤
base_dir = base_dir.replace("../", "")
base_dir = re.sub(r"^/+", "", base_dir)
if not os.path.exists(base_dir + upload_path):
os.makedirs(base_dir + upload_path)
if not filename:
uuidhex = uuid.uuid1().hex
file_ext = os.path.splitext(fileobj["filename"])[1].lower()
filename = uuidhex + file_ext
if not os.path.exists(base_dir + upload_path + filename):
with open(base_dir + upload_path + filename, "wb") as f:
f.write(fileobj["body"])
result = {
"state": "SUCCESS",
"url": upload_path + filename,
"title": filename,
"original": fileobj["filename"],
}
u4Ts.append_file(upload_path + filename, is_image=is_image)
return result
# self.write(result)
# self.finish()
@gen.coroutine
def get(self):
action = self.get_argument("action")
if action == "config":
self.write(ueditor_config)
return
elif action == u4Ts.config["imageManagerActionName"]:
start = int(self.get_argument("start"))
size = int(self.get_argument("size"))
urls = u4Ts.get_list(start, size, is_image=True)
result = {
"state": "SUCCESS",
"list": urls,
"start": start,
"total": len(urls),
}
# self.write(result)
# self.finish()
return result
elif action == u4Ts.config["fileManagerActionName"]:
start = int(self.get_argument("start"))
size = int(self.get_argument("size"))
urls = u4Ts.get_list(start, size, is_image=False)
result = {
"state": "SUCCESS",
"list": urls,
"start": start,
"total": len(urls),
}
self.write(result)
self.finish()
return
self.finish()
@gen.coroutine
def post(self):
data = {}
action = self.get_argument("action")
if action == u4Ts.config["imageActionName"]:
for keys in self.request.files:
for fileobj in self.request.files[keys]:
data = yield self.save_file(
base_dir=u4Ts.config["imagePathFormat"],
fileobj=fileobj)
elif action == u4Ts.config["scrawlActionName"]:
# python2
# fileobj = {'filename': 'scrawl.png', 'body': base64.decodestring(self.get_argument(u4Ts.config['scrawlFieldName']))}
# python3
fileobj = {
"filename":
"scrawl.png",
"body":
base64.decodebytes(
self.get_argument(
u4Ts.config["scrawlFieldName"]).encode("utf-8")),
}
data = yield self.save_file(
base_dir=u4Ts.config["scrawlPathFormat"], fileobj=fileobj)
elif action == u4Ts.config["snapscreenActionName"]:
for keys in self.request.files:
for fileobj in self.request.files[keys]:
data = yield self.save_file(
base_dir=u4Ts.config["snapscreenPathFormat"],
fileobj=fileobj)
elif action == u4Ts.config["videoActionName"]:
for keys in self.request.files:
for fileobj in self.request.files[keys]:
data = yield self.save_file(
base_dir=u4Ts.config["videoPathFormat"],
fileobj=fileobj)
elif action == u4Ts.config["fileActionName"]:
for keys in self.request.files:
for fileobj in self.request.files[keys]:
data = yield self.save_file(
base_dir=u4Ts.config["filePathFormat"],
fileobj=fileobj,
is_image=False,
)
self.set_header("Content-Type", "text/html")
self.write(json.dumps(data))
self.finish()
from tornado import web
from tornado.concurrent import futures
from sqlalchemy import create_engine
from ..libs.paginator import Paginator
from ..libs.utils import import_object
from ..middlewares import MiddlewareProcess
from ..models import Session as DBSession
from ..models import User
from ..models.base import redis_cli
from ..models.sys_config import SysConfig
from ..session import Session
thread_pool = futures.ThreadPoolExecutor()
process_pool = futures.ProcessPoolExecutor()
class BaseHandler(web.RequestHandler):
"""Handler的基类"""
_db = None
_redis_cli = None
_session = None
_cache_client = None
thread_pool = thread_pool
process_pool = process_pool
@property
def cache_client(self):
if not self._cache_client:
def __init__(self, api):
self.io_loop = ioloop.IOLoop.current()
self.executor = futures.ThreadPoolExecutor(8)
self.api = api
self.gitolite = Gitolite(conf.gitolite_wd,
self.repo_url('gitolite-admin'))
print("CurrentBuffer:", frameBuffer)
if len(frameBuffer) < 24:
continue
loop.run_in_executor(
None, partial(self.wrappedDecode, frameBuffer, Q))
status = Q.get()
frameBuffer = b''
if status == self.DECODE_SUC:
await stream.write(bytes([0x3e]))
else:
await stream.write(bytes([0x6c]))
except StreamClosedError:
print("connection closed from {0:s}:{1:d}".format(
address[0], address[1]))
break
except gen.TimeoutError:
frameBuffer = b''
print("No response in 3 seconds {0:s}:{1:d}".format(
address[0], address[1]))
loop = IOLoop.current() #type: IOLoop
loop.set_default_executor(futures.ThreadPoolExecutor(max_workers=10))
server = SSCServer()
print("server listening at 2334")
server.listen('2334')
loop.start()
def _create_context(self):
executors = {
name: futures.ThreadPoolExecutor(threads)
for name, threads in self.settings["threads"].items()
}
return self.context_class(self.settings, executors, **self.objects)
import os
from pypi_server.handlers.base import BaseHandler
from tempfile import NamedTemporaryFile
from pypi_server.db import init_db, DB
from tornado.testing import AsyncHTTPTestCase
from pypi_server.server import create_app
from rest_client. async import RESTClient
from tornado.testing import gen_test
from tornado.httpclient import HTTPRequest, HTTPError
from tornado.concurrent import futures
from tornado.gen import Return, coroutine
import logging
BaseHandler.THREAD_POOL = futures.ThreadPoolExecutor(2)
class TestCase(AsyncHTTPTestCase):
def setUp(self):
super(TestCase, self).setUp()
# Init DB
self.__db_file = NamedTemporaryFile(mode="r+")
logging.getLogger("peewee").setLevel(logging.WARNING)
init_db("sqlite://{0}".format(self.__db_file.name))
logging.getLogger("peewee").setLevel(logging.DEBUG)
def get_app(self):
return create_app(
secret=os.urandom(32),
io_loop=self.io_loop,
def _create_context(self):
executor = futures.ThreadPoolExecutor((os.cpu_count() or 1) * 5)
return self.context_class(self.settings, executor, **self.objects)
class PayPalService(object):
executor = futures.ThreadPoolExecutor()
paypal_client = PayPalClient(
mode=Config.PAYPAL_CONFIG['client_info']['mode'],
client_id=Config.PAYPAL_CONFIG['client_info']['client_id'],
client_secret=Config.PAYPAL_CONFIG['client_info']['client_secret']
)
@classmethod
@run_on_executor
def checkout(cls, size, quantity, total):
"""用户结账"""
# 查找是否web profile对象已经创建
web_profile_name = Config.PAYPAL_CONFIG['webprofile']
web_profile_id = (cls.paypal_client
._traverse_web_profile_id(web_profile_name))
if web_profile_id is None:
# 创建新的web profile对象
web_profile_info = (cls.paypal_client
._web_profile_create(name=web_profile_name))
if web_profile_info['error'] != 0: # 发生错误
return web_profile_info
web_profile_obj = web_profile_info['obj']
web_profile_id = web_profile_obj.id
transaction_info = cls._get_transactions_info(size, quantity, total)
payment_info = {
"payer": {
"payment_method": "paypal"
},
"redirect_urls": {
"return_url": Config.PAYPAL_CONFIG['redirect_urls']
['return_url'],
"cancel_url": Config.PAYPAL_CONFIG['redirect_urls']
['cancel_url']
},
"transactions": transaction_info,
"experience_profile_id": web_profile_id
}
# 创建payment对象
payment_obj = cls.paypal_client._payment_create(**payment_info)
# 发送payment对象
status = cls.paypal_client._payment_sent(payment_obj)
if status['error'] != 0: # 发生错误
return status
# 获取重定向URL
redirect_url = cls.paypal_client._payment_redirect(payment_obj)
status['redirect_url'] = redirect_url
status['payment_id'] = payment_obj['id']
return status
@classmethod
@run_on_executor
def order_execute(cls, payment_id, payer_id):
"""这是一个支付执行的代理函数，在它的上面加上了@run_on_executor装饰器"""
result = cls.paypal_client._payment_execute(payment_id=payment_id,
payer_id=payer_id)
return result
@classmethod
def _get_transactions_info(cls, size, quantity, total):
"""生成交易信息"""
transactions = [{
"item_list": {
"items": [{
"name": "legging " + str(size),
"sku": "LG001",
"price": "19.99",
"currency": "USD",
"quantity": quantity
}]},
"amount": {
"total": str(total),
"currency": "USD"
},
"description": "niceline legging"
}]
return transactions
@classmethod
def _get_total_price(cls, quantity, unit_price='19.99'):
total_price = Decimal(unit_price) * quantity
return total_price
def __init__(self, loop=None):
self.executor = futures.ThreadPoolExecutor(4)
self.loop = loop or IOLoop.instance()
def __init__(self, loop=None):
self.executor = futures.ThreadPoolExecutor(60)
self.loop = loop or tornado.ioloop.IOLoop.current()
def __init__(self, application, request, **kwargs):
super().__init__(application, request, **kwargs)
self.receiver = None
self.executor = futures.ThreadPoolExecutor(max_workers=4)
class S3Storage(AbstractStorage):
"""Class to handle S3 uploads."""
executor = futures.ThreadPoolExecutor(5)
def __init__(self):
"""Constructor."""
super(S3Storage, self).__init__()
# For now don't enable verbose boto logs
# TODO(armando): Make this configurable.
log = logging.getLogger("botocore")
log.propagate = False
assert (config.get_option("global.sharingMode") !=
"off"), 'Sharing is disabled. See "global.sharingMode".'
self._bucketname = config.get_option("s3.bucket")
self._url = config.get_option("s3.url")
self._key_prefix = config.get_option("s3.keyPrefix")
self._region = config.get_option("s3.region")
user = os.getenv("USER", None)
if self._url and "{USER}" in self._url:
self._url = self._url.replace("{USER}", user)
if self._key_prefix and "{USER}" in self._key_prefix:
self._key_prefix = self._key_prefix.replace("{USER}", user)
# URL where browsers go to load the Streamlit web app.
self._web_app_url = None
if not self._url:
self._web_app_url = os.path.join(
"https://%s.%s" % (self._bucketname, "s3.amazonaws.com"),
self._s3_key("index.html"),
)
else:
self._web_app_url = os.path.join(
self._url, self._s3_key("index.html", add_prefix=False))
aws_profile = config.get_option("s3.profile")
access_key_id = config.get_option("s3.accessKeyId")
secret_access_key = config.get_option("s3.secretAccessKey")
if aws_profile is not None:
LOGGER.debug('Using AWS profile "%s".', aws_profile)
self._s3_client = boto3.Session(
profile_name=aws_profile).client("s3")
elif access_key_id is not None and secret_access_key is not None:
self._s3_client = boto3.client(
"s3",
aws_access_key_id=access_key_id,
aws_secret_access_key=secret_access_key,
)
else:
LOGGER.debug("Using default AWS profile.")
self._s3_client = boto3.client("s3")
@run_on_executor
def _get_static_upload_files(self):
"""Return a list of static files to upload.
Returns an empty list if the files are already uploaded.
"""
try:
self._s3_client.head_object(Bucket=self._bucketname,
Key=self._s3_key("index.html"))
return []
except botocore.exceptions.ClientError:
return list(self._static_files)
@run_on_executor
def _bucket_exists(self):
# THIS DOES NOT WORK because the aws exception isn't being
# caught and disappearing.
try:
self._s3_client.head_bucket(Bucket=self._bucketname)
except botocore.exceptions.ClientError as e:
LOGGER.warning(
'"%s" bucket not found. Do you have s3:HeadBucket permission?',
self._bucketname,
)
LOGGER.warning(e)
return False
return True
@run_on_executor
def _create_bucket(self):
LOGGER.debug('Attempting to create "%s" bucket', self._bucketname)
self._s3_client.create_bucket(
ACL="public-read",
Bucket=self._bucketname,
CreateBucketConfiguration={"LocationConstraint": self._region},
)
LOGGER.debug('"%s" bucket created', self._bucketname)
@gen.coroutine
def _s3_init(self):
"""Initialize s3 bucket."""
try:
bucket_exists = yield self._bucket_exists()
if not bucket_exists:
LOGGER.warning("Will attempt to create bucket")
yield self._create_bucket()
except botocore.exceptions.NoCredentialsError:
LOGGER.error(
'Please set "AWS_ACCESS_KEY_ID" and "AWS_SECRET_ACCESS_KEY" '
"environment variables")
raise errors.S3NoCredentials
def _s3_key(self, relative_path, add_prefix=True):
"""Convert a local file path into an s3 key (ie path)."""
key = os.path.join(self._release_hash, relative_path)
if add_prefix:
key = os.path.join(self._key_prefix, key)
return os.path.normpath(key)
@gen.coroutine
def _save_report_files(self,
report_id,
files,
progress_coroutine=None,
manifest_save_order=None):
"""Save files related to a given report.
See AbstractStorage for docs.
"""
LOGGER.debug("Saving report %s", report_id)
yield self._s3_init()
static_files = yield self._get_static_upload_files()
files_to_upload = static_files + files
if manifest_save_order is not None:
manifest_index = None
manifest_tuple = None
for i, file_tuple in enumerate(files_to_upload):
if file_tuple[0] == "manifest.json":
manifest_index = i
manifest_tuple = file_tuple
break
if manifest_tuple:
files_to_upload.pop(manifest_index)
if manifest_save_order == "first":
files_to_upload.insert(0, manifest_tuple)
else:
files_to_upload.append(manifest_tuple)
yield self._s3_upload_files(files_to_upload, progress_coroutine)
raise gen.Return("%s?id=%s" % (self._web_app_url, report_id))
@gen.coroutine
def _s3_upload_files(self, files, progress_coroutine):
set_private_acl = config.get_option("s3.requireLoginToView")
for i, (path, data) in enumerate(files):
mime_type = mimetypes.guess_type(path)[0]
if not mime_type:
mime_type = "application/octet-stream"
if set_private_acl and path.startswith("report"):
acl = "private"
else:
acl = "public-read"
self._s3_client.put_object(
Bucket=self._bucketname,
Body=data,
Key=self._s3_key(path),
ContentType=mime_type,
ACL=acl,
)
LOGGER.debug('Uploaded: "%s"', path)
if progress_coroutine:
yield progress_coroutine(math.ceil(100 * (i + 1) / len(files)))
else:
yield
class AsyncHTTPTestCase(testing.AsyncHTTPTestCase):
executor = futures.ThreadPoolExecutor(10)
def get_app(self):
return web.Application([(r'/(.*)', RequestHandler)])
def run():
options.parse_command_line()
if options.config:
options.parse_config_file(options.config)
options.storage = os.path.abspath(options.storage)
if os.getuid() == 0 and options.user:
pw = pwd.getpwnam(options.user)
uid, gid = pw.pw_uid, pw.pw_gid
log.info("Changind user to %s [%s:%s]", options.user, uid, gid)
os.setgid(uid)
os.setuid(uid)
try:
if not all(f(options.storage) for f in (os.path.exists, os.path.isdir)):
log.info('Creating new package storage directory: "%s"', options.storage)
os.makedirs(options.storage)
def on_interrupt(*args):
log.warning("Receiving interrupt signal. Application will be stopped.")
exit(errno.EINTR)
log.debug("Preparing signal handling")
for sig in (signal.SIGINT, signal.SIGTERM, signal.SIGQUIT):
signal.signal(sig, on_interrupt)
def handle_pdb(sig, frame):
import pdb
pdb.Pdb().set_trace(frame)
if options.debug:
signal.signal(signal.SIGUSR2, handle_pdb)
log.debug("Creating application instance")
app = create_app(
options.debug,
options.secret,
options.gzip,
)
log.debug("Creating IOLoop instance.")
io_loop = IOLoop.current()
io_loop.run_sync(lambda: init_db(options.database))
if not (os.path.exists(options.cache_dir) and os.path.isdir(options.cache_dir)):
os.makedirs(options.cache_dir)
Cache.CACHE_DIR = options.cache_dir
log.info("Init thread pool with %d threads", options.pool_size)
handlers.base.BaseHandler.THREAD_POOL = futures.ThreadPoolExecutor(options.pool_size)
AsyncHTTPClient.configure(None, max_clients=options.max_http_clients)
proxy_url = URL(os.getenv('{0}_proxy'.format(options.pypi_server.scheme)))
if proxy_url:
log.debug("Configuring for proxy: %s", proxy_url)
AsyncHTTPClient.configure(
'tornado.curl_httpclient.CurlAsyncHTTPClient',
defaults={
'proxy_host': proxy_url.host,
'proxy_port': proxy_url.port,
'proxy_username': proxy_url.user,
'proxy_password': proxy_url.password,
}
)
PYPIClient.configure(
options.pypi_server,
handlers.base.BaseHandler.THREAD_POOL
)
if options.pypi_proxy:
pypi_updater = PeriodicCallback(PYPIClient.packages, HOUR * 1000, io_loop)
io_loop.add_callback(PYPIClient.packages)
io_loop.add_callback(pypi_updater.start)
log.info("Starting server http://%s:%d/", options.address, options.port)
http_server = HTTPServer(app, xheaders=options.proxy_mode)
http_server.listen(options.port, address=options.address)
log.debug('Setting "%s" as storage', options.storage)
PackageFile.set_storage(options.storage)
log.debug("Starting main loop")
io_loop.start()
except Exception as e:
log.fatal("Exception on main loop:")
log.exception(e)
exit(1)
else:
exit(0)
class UploadHandler(BaseHandler):
executor = futures.ThreadPoolExecutor(100)
@run_on_executor()
def save_file(self, fileobj, base_dir, filename=None, user=None, is_image=True):
if not user:
user = '******'
upload_path = user + '/' + datetime.datetime.utcnow().strftime('%Y%m%d') + '/'
# 安全过滤
base_dir = base_dir.replace('../', '')
base_dir = re.sub(r'^/+', '', base_dir)
if not os.path.exists(base_dir + upload_path):
os.makedirs(base_dir + upload_path)
if not filename:
uuidhex = uuid.uuid1().hex
file_ext = os.path.splitext(fileobj['filename'])[1].lower()
filename = uuidhex + file_ext
if not os.path.exists(base_dir + upload_path + filename):
with open(base_dir + upload_path + filename, 'wb') as f:
f.write(fileobj['body'])
result = {
'state': 'SUCCESS',
'url': upload_path + filename,
'title': filename,
'original': fileobj['filename'],
}
u4Ts.append_file(upload_path + filename, is_image=is_image)
return result
# self.write(result)
# self.finish()
@gen.coroutine
def get(self):
action = self.get_argument('action')
if action == 'config':
self.write(ueditor_config)
return
elif action == u4Ts.config['imageManagerActionName']:
start = int(self.get_argument('start'))
size = int(self.get_argument('size'))
urls = u4Ts.get_list(start, size, is_image=True)
result = {
'state': 'SUCCESS',
'list': urls,
'start': start,
'total': len(urls)
}
# self.write(result)
# self.finish()
return result
elif action == u4Ts.config['fileManagerActionName']:
start = int(self.get_argument('start'))
size = int(self.get_argument('size'))
urls = u4Ts.get_list(start, size, is_image=False)
result = {
'state': 'SUCCESS',
'list': urls,
'start': start,
'total': len(urls)
}
self.write(result)
self.finish()
return
self.finish()
@gen.coroutine
def post(self):
data = {}
action = self.get_argument('action')
if action == u4Ts.config['imageActionName']:
for keys in self.request.files:
for fileobj in self.request.files[keys]:
data = yield self.save_file(base_dir=u4Ts.config['imagePathFormat'], fileobj=fileobj)
elif action == u4Ts.config['scrawlActionName']:
# python2
# fileobj = {'filename': 'scrawl.png', 'body': base64.decodestring(self.get_argument(u4Ts.config['scrawlFieldName']))}
# python3
fileobj = {'filename': 'scrawl.png',
'body': base64.decodebytes(self.get_argument(u4Ts.config['scrawlFieldName']).encode('utf-8'))}
data = yield self.save_file(base_dir=u4Ts.config['scrawlPathFormat'], fileobj=fileobj)
elif action == u4Ts.config['snapscreenActionName']:
for keys in self.request.files:
for fileobj in self.request.files[keys]:
data = yield self.save_file(base_dir=u4Ts.config['snapscreenPathFormat'], fileobj=fileobj)
elif action == u4Ts.config['videoActionName']:
for keys in self.request.files:
for fileobj in self.request.files[keys]:
data = yield self.save_file(base_dir=u4Ts.config['videoPathFormat'], fileobj=fileobj)
elif action == u4Ts.config['fileActionName']:
for keys in self.request.files:
for fileobj in self.request.files[keys]:
data = yield self.save_file(base_dir=u4Ts.config['filePathFormat'], fileobj=fileobj, is_image=False)
self.set_header("Content-Type", "text/html")
self.write(json.dumps(data))
self.finish()
class UploadHandler(BaseHandler):
'''文件上传处理'''
executor = futures.ThreadPoolExecutor(2048)
@authenticated
@tornado.web.asynchronous
@tornado.gen.coroutine
def post(self, *args, **kwargs):
utype = self.get_argument('utype', 'normal').encode('UTF-8')
post_data = {}
for key in self.request.arguments:
post_data[key] = self.get_arguments(key)
if utype == 'excel':
yield self.savexcel()
elif utype == 'icloud':
yield self.saveicloud()
else:
yield self.savenormal()
@run_on_executor
def savenormal(self):
'''保存图片'''
width = int(self.get_argument('width', 500))
height = int(self.get_argument('height', 500))
quality = int(self.get_argument('quality', 80))
#取NGINX传来的文件参数
file_name = self.get_argument('last-calls_name', 'uploaded.file')
file_content_type = self.get_argument('last-calls_content_type', "")
# file_size = self.get_argument('file_size', -1)
file_md5 = self.get_argument('last-calls_md5', '')
file_path = self.get_argument('last-calls_path', '').encode('UTF-8')
# 基础信息验证
if len(file_name) < 1 or len(file_content_type) < 1 or len(
file_md5) < 6 or len(file_path) < 1:
if len(file_path) > 1:
os.remove(file_path)
self.write({
"state": state.API_FAIL[0],
"msg": state.API_FAIL[1],
"result": {}
})
return
#判断文件类型
if not file_content_type or (file_content_type != "image/jpeg"
and file_content_type != "image/png"):
os.remove(file_path)
self.write({
"state": state.API_ERROR_FILE_FORMANT[0],
"msg": state.API_ERROR_FILE_FORMANT[1],
"result": {}
})
return
tmp_file_path = hand_photo(file_md5, file_path, width, height, quality)
if tmp_file_path:
new_file_name = os.path.basename(tmp_file_path)
ret_path = os.path.join("/static/upload/tmp", new_file_name)
self.write({
"state": state.WEB_SUCCESS[0],
"msg": state.WEB_SUCCESS[1],
"result": ret_path
})
else:
self.write({
"state": state.WEB_FAIL[0],
"msg": state.WEB_FAIL[1],
"result": {}
})
@run_on_executor
def savexcel(self):
'''保存文件'''
#取NGINX传来的文件参数
file_name = self.get_argument('last-calls_name', 'uploaded.file')
file_content_type = self.get_argument('last-calls_content_type', "")
# file_size = self.get_argument('file_size', -1)
file_md5 = self.get_argument('last-calls_md5', '')
file_path = self.get_argument('last-calls_path', '').encode('UTF-8')
# 基础信息验证
if len(file_name) < 1 or len(file_content_type) < 1 or len(
file_md5) < 6 or len(file_path) < 1:
if len(file_path) > 1:
os.remove(file_path)
self.write({
"state": state.WEB_FAIL_PARAMS[0],
"msg": state.WEB_FAIL_PARAMS[1],
"result": {}
})
return
#判断文件类型
if not file_content_type or (
file_content_type !=
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
and file_content_type != "application/octet-stream"):
os.remove(file_path)
self.write({
"state": state.WEB_ERROR_FILE_FORMANT[0],
"msg": state.WEB_ERROR_FILE_FORMANT[1],
"result": {}
})
return
calls_tuples = excel.read_excel_tuple(file_path)
try:
os.remove(file_path)
except IOError as ex:
app_log(ex)
if calls_tuples:
timeStartIndex = -1
calltimeIndex = -1
callTypeIndex = -1
phoneIndex = -1
localAddIndex = -1
desAddIndex = -1
if calls_tuples[0].count("通话起始时间") > 0:
timeStartIndex = calls_tuples[0].index("通话起始时间")
if calls_tuples[0].count("通话时长") > 0:
calltimeIndex = calls_tuples[0].index("通话时长")
if calls_tuples[0].count("呼叫类型") > 0:
callTypeIndex = calls_tuples[0].index("呼叫类型")
if calls_tuples[0].count("对方号码") > 0:
phoneIndex = calls_tuples[0].index("对方号码")
if calls_tuples[0].count("本机通话地") > 0:
localAddIndex = calls_tuples[0].index("本机通话地")
if calls_tuples[0].count("对方归属地") > 0:
desAddIndex = calls_tuples[0].index("对方归属地")
if timeStartIndex < 0 or calltimeIndex < 0 or callTypeIndex < 0 or phoneIndex < 0 or localAddIndex < 0 or desAddIndex < 0:
self.write({
"state": state.WEB_FAIL[0],
"msg": "格式错误",
"result": calls_tuples
})
return
calls = []
del calls_tuples[0]
for row in calls_tuples:
new_row = (row[timeStartIndex], row[calltimeIndex],
row[callTypeIndex], row[phoneIndex],
row[localAddIndex], row[desAddIndex])
calls.append(new_row)
self.write({
"state": state.WEB_SUCCESS[0],
"msg": state.WEB_SUCCESS[1],
"result": calls
})
else:
self.write({
"state": state.WEB_FAIL[0],
"msg": state.WEB_FAIL[1],
"result": {}
})
@run_on_executor
def saveicloud(self):
'''保存icloud'''
#取NGINX传来的文件参数
file_name = self.get_argument('last-calls_name', 'uploaded.file')
file_content_type = self.get_argument('last-calls_content_type', "")
# file_size = self.get_argument('file_size', -1)
file_md5 = self.get_argument('last-calls_md5', '')
file_path = self.get_argument('last-calls_path', '').encode('UTF-8')
# 基础信息验证
if len(file_name) < 1 or len(file_content_type) < 1 or len(
file_md5) < 6 or len(file_path) < 1:
if len(file_path) > 1:
os.remove(file_path)
self.write({
"state": state.WEB_FAIL_PARAMS[0],
"msg": state.WEB_FAIL_PARAMS[1],
"result": {}
})
return
#判断文件类型
if not file_content_type or (
file_content_type !=
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
and file_content_type != "application/octet-stream"):
os.remove(file_path)
self.write({
"state": state.WEB_ERROR_FILE_FORMANT[0],
"msg": state.WEB_ERROR_FILE_FORMANT[1],
"result": {}
})
return
calls_tuples = excel.read_excel_tuple(file_path)
try:
os.remove(file_path)
except IOError as ex:
app_log(ex)
if calls_tuples:
del calls_tuples[0]
self.write({
"state": state.WEB_SUCCESS[0],
"msg": state.WEB_SUCCESS[1],
"result": calls_tuples
})
else:
self.write({
"state": state.WEB_FAIL[0],
"msg": state.WEB_FAIL[1],
"result": {}
})
