def zip_upload(self, zip_file, zip_name=None):
     if not zip_name:
         zip_name = str(uuid.uuid1())
     mime_type = 'application/zip'
     token = q.upload_token(qiniu_bucket_name, zip_name)
     qiniu.put_data(token, zip_name, zip_file, mime_type=mime_type, check_crc=True)
     return '%s/%s' % (qiniu_resource_url, zip_name)

def get_img_path(url):
    img = requests.get(url)
    md5 = hashlib.md5()
    md5.update(img.content)
    key = md5.hexdigest()
    put_data(token, key, img.content)
    return baseurl + '/' + key

 def excel_upload(self, excel_file, excel_name=None):
     if not excel_name:
         excel_name = str(uuid.uuid1())
     mime_type = 'application/ms-excel'
     token = q.upload_token(qiniu_bucket_name, excel_name)
     qiniu.put_data(token, excel_name, excel_file, mime_type=mime_type, check_crc=True)
     return '%s/%s' % (qiniu_resource_url, excel_name)

def get_img_url(img):
    print img
    md5 = hashlib.md5()
    md5.update(img)
    key = md5.hexdigest()
    put_data(token, key,img,mime_type='image/jpeg')
    return baseurl + '/' + key

 def image_upload(self, img_file, image_name=None):
     if not image_name:
         image_name = str(uuid.uuid1())
     mime_type = 'image/jpg'
     token = q.upload_token(qiniu_bucket_name, image_name)
     qiniu.put_data(token, image_name, img_file, mime_type=mime_type, check_crc=True)
     return '%s/%s' % (qiniu_resource_url, image_name)

def upload_file(data):
    """
    上传文件
    :param data: data文件数据
    :return:
    """
    key = other_config.prefix + hashlib.md5(data).hexdigest()

    q = Auth(other_config.access_key, other_config.secret_key)
    token = q.upload_token(other_config.bucket_name)
    put_data(token, key, data)

    return other_config.url + key

    def test_putWithoutKey(self):
        key = None
        data = "hello bubby!"
        token = self.q.upload_token(bucket_name)
        ret, info = put_data(token, key, data)
        print(info)
        assert ret["hash"] == ret["key"]

        data = "hello bubby!"
        token = self.q.upload_token(bucket_name, "nokey2")
        ret, info = put_data(token, None, data)
        print(info)
        assert ret is None
        assert info.status_code == 403  # key not match

    def test_put(self):
        key = 'a\\b\\c"你好'
        data = 'hello bubby!'
        token = self.q.upload_token(bucket_name)
        ret, info = put_data(token, key, data)
        print(info)
        assert ret['key'] == key

        key = ''
        data = 'hello bubby!'
        token = self.q.upload_token(bucket_name, key)
        ret, info = put_data(token, key, data, check_crc=True)
        print(info)
        assert ret['key'] == key

def qiniu_upload_fileobj(obj, bucket_name, ext=None):
    '''
        把request.FILES里的文件对象上传到七牛
        obj: 文件对象
        bucket_name: 七牛的bucket
        ext: 为七牛的key追加的扩展名，包含.符号
    '''
    if not ext:
        ext = os.path.splitext(obj.name)[1]

    full_name = '%s/%s%s' % (
        datetime.datetime.now().strftime('%Y%m%d/%H%M%S'),
        _key(10).lower(),
        ext
    )
    q = qiniu.Auth(AK, SK)
    token = q.upload_token(bucket_name, full_name)
    data = ''
    for chunk in obj.chunks():
        data += chunk
    ret, info = qiniu.put_data(token, full_name, data, mime_type=obj.content_type)
    if ret:
        return full_name
    else:
        logger.debug('qiniu upload err: %s', info)

def storage(file_data):
    try:
        #构建鉴权对象
        q = Auth(access_key, secret_key)

        #要上传的空间
        bucket_name = 'ihome'

        #上传到七牛后保存的文件名
        # key = 'my-python-logo.png';


        #生成上传 Token，可以指定过期时间等

        token = q.upload_token(bucket_name)

        #要上传文件的本地路径
        # localfile = './sync/bbb.jpg'
        # ret, info = put_file(token, key, localfile)
        ret, info = put_data(token, None, file_data)
    except Exception as e:
        logging.error(e)
        raise e
    print(ret)
    print("*"*16)
    print(info)
    # assert ret['key'] == key
    # assert ret['hash'] == etag(localfile)
    print(type(info))
    print(info.status_code)
    if 200 == info.status_code:
        return ret["key"]
    else:
        raise Exception("上传失败")

    def post(self):
        for i in request.forms.keys():
            print i, request.forms[i], type(request.forms[i])

        for i in request.files.keys():
            print i, request.files[i], type(request.files[i])
            print request.files[i].__dict__

        image = request.files['image']
        name = image.raw_filename
        data = image.file.read()
        key = md5('data').hexdigest() + '.' + name.split('.')[-1]

        auth = Auth(QINIU_ACCESS_KEY, QINIU_SECRET_KEY)
        token = auth.upload_token(
            QINIU_BUCKET_NAME, None, 7200,
            {
                'returnBody': json.dumps({
                    'key': '$(key)',
                    'hash': '$(etag)',
                    'format': '$(imageInfo.format)',
                    'width': '$(imageInfo.width)',
                    'height': '$(imageInfo.height)',
                }),
                'save_key': '$(etag)',
            }
        )
        ret, info = put_data(token, key, data)

 def test_put_crc(self):
     key = ""
     data = "hello bubby!"
     token = self.q.upload_token(bucket_name, key)
     ret, info = put_data(token, key, data, check_crc=True)
     print(info)
     assert ret["key"] == key

def upload_to_qiniu(AK, SK, BUCKET_NAME,FILE_OBJ,FILE_NAME,):
    '''
    上传文件到七牛云，并返回 文件hash

    BUCKET_NAME 七牛资源空间名
    FILE_OBJ 文件二进制流
    FILE_NAME 文件保存到七牛云上的文件名
    '''
    q = Auth(AK, SK)
    token = q.upload_token(BUCKET_NAME, FILE_NAME, 3600)
    # ret
    # 一个dict变量，类似 {"hash": "<Hash string>", "key": "<Key string>"}
    # info
    """七牛HTTP请求返回信息类

    该类主要是用于获取和解析对七牛发起各种请求后的响应包的header和body。

    Attributes:
        status_code: 整数变量，响应状态码
        text_body:   字符串变量，响应的body
        req_id:      字符串变量，七牛HTTP扩展字段，参考 http://developer.qiniu.com/docs/v6/api/reference/extended-headers.html
        x_log:       字符串变量，七牛HTTP扩展字段，参考 http://developer.qiniu.com/docs/v6/api/reference/extended-headers.html
        error:       字符串变量，响应的错误内容
    """
    ret, info = put_data(token, FILE_NAME, FILE_OBJ)
    if info.status_code:
        if ret['hash'] == etag_stream(FILE_OBJ):
            return ret['hash']
        return None
    return None

    def post(self, template_variables = {}):
        template_variables = {}
        # validate the fields
        if("files" in self.request.files):            
            file_name = "%s" % uuid.uuid1()
            file_raw = self.request.files["files"][0]["body"]
            file_buffer = StringIO.StringIO(file_raw)
            file = Image.open(file_buffer)

            usr_home = os.path.expanduser('~')
            file.save(usr_home+"/%s.png" % file_name, "PNG")  

            uptoken = q.upload_token("yx-img", "%s.png" % file_name)
            data=open(usr_home+"/%s.png" % file_name)
            ret, info = put_data(uptoken, "%s.png" % file_name, data)
 
            os.remove(usr_home+"/%s.png" % file_name)

            file_name = "http://objdsnsh2.bkt.clouddn.com/"+file_name+".png"
            print file_name

            self.write(lib.jsonp.print_JSON({
                    "files": [
                        {
                            "name": file_name,
                        }]
            }))

 def test_put(self):
     key = 'a\\b\\c"hello'
     data = 'hello bubby!'
     token = self.q.upload_token(bucket_name)
     ret, info = put_data(token, key, data)
     print(info)
     assert ret['key'] == key

    def create(self):
        # TODO: 表单验证
        image = request.files['image']
        # TODO: 解包检查
        origin_name, suffix = image.raw_filename.split('.')

        data = image.file.read()
        data_hash = md5(data).hexdigest()
        key = data_hash

        model = ImageModel.query.get(data_hash)
        if model:
            return model.as_dict()

        auth = Auth(QINIU_ACCESS_KEY, QINIU_SECRET_KEY)
        token = auth.upload_token(
            QINIU_BUCKET_NAME, None, 7200,
            {
                'returnBody': json.dumps({
                    'key': '$(key)',
                    'hash': '$(etag)',
                    'format': '$(imageInfo.format)',
                    'width': '$(imageInfo.width)',
                    'height': '$(imageInfo.height)',
                }),
                'save_key': '$(etag)',
            }
        )
        ret, info = put_data(token, key, data)
        model = ImageModel(
            hashkey=data_hash, suffix=ret['format'],
            width=ret['width'], height=ret['height'])
        db.session.add(model)
        db.session.commit()
        return model.as_dict()

def upload_file(file_name=None, data=None):
    if not file_name:
        file_name = hashlib.md5(data).hexdigest()
    q = Auth(settings.QINIU_KEY, settings.QINIU_TOKEN)
    token = q.upload_token(settings.QINIU_BUCKET)
    ret, info = put_data(token, file_name, data)
    return ret['key'] == file_name, file_name

    def _save_to_qiniu(self):
        import qiniu
        output = BytesIO()
        self._source.seek(0)
        base64.encode(self._source, output)
        self._source.seek(0)
        output.seek(0)
        hex_octet = lambda: hex(int(0x10000 * (1 + random.random())))[-4:]
        key = ''.join(hex_octet() for _ in range_type(4))
        key = '{0}.{1}'.format(key, self.extension)
        data = {
            'name': self._name,
            'key': key,
            'ACL': self._acl,
            'mime_type': self._type,
            'metaData': self._metadata,
        }
        response = client.post('/qiniu', data)
        content = response.json()
        self.id = content['objectId']
        self._url = content['url']
        uptoken = content['token']
        ret, info = qiniu.put_data(uptoken, key, self._source)

        if info.status_code != 200:
            raise LeanCloudError(1, 'the file is not saved, qiniu status code: {0}'.format(info.status_code))

 def upload(self, data, path):
     token = q.upload_token(self.scope)
     data.seek(0)
     ret, _ = _q.put_data(token, path, data)
     if ret:
         return path, ret['hash']
     raise UploadFailedError

    def uploadData(data):
        if type(data) == QByteArray:
            data = data.data()

        from .secfg import qiniu_acckey, qiniu_seckey, qiniu_bucket_name
        access_key = qiniu_acckey
        secret_key = qiniu_seckey
        bucket_name = qiniu_bucket_name

        print(access_key, secret_key, bucket_name)
        q = qiniu.Auth(access_key, secret_key)
        # 由于本机时间错误，导致计算了出的token立即失效：
        # text_body:{"error":"expired token"}
        token = q.upload_token(bucket_name, expires=3600*24)
        key = 'helloqt.png'
        key = FileStore.md5sum(data)
        # data = 'hello qiniu!'
        # data = load_from_file(PATH)
        print('uploading file:', key, token)
        ret, info = qiniu.put_data(token, key, data)
        if ret is not None:
            print('upload file All is OK', ret)
            url = 'http://7xn2rb.com1.z0.glb.clouddn.com/%s' % key
            return url
        else:
            print(ret, '=====', info)  # error message in info
        return str(info)