def file_url(self, host):
url = ['{0}/mkfile/{1}'.format(host, self.size)]
if self.mime_type:
url.append('mimeType/{0}'.format(
urlsafe_base64_encode(self.mime_type)))
if self.key is not None:
url.append('key/{0}'.format(urlsafe_base64_encode(self.key)))
if self.file_name is not None:
url.append('fname/{0}'.format(urlsafe_base64_encode(
self.file_name)))
if self.params:
for k, v in self.params.items():
url.append('{0}/{1}'.format(k, urlsafe_base64_encode(v)))
pass
if self.modify_time and self.keep_last_modified:
url.append("x-qn-meta-!Last-Modified/{0}".format(
urlsafe_base64_encode(rfc_from_timestamp(self.modify_time))))
url = '/'.join(url)
# print url
return url
def upload_staff_file(request):
form = forms.UploadStafffile(request.POST)
if not form.is_valid():
e = ','.join([form.errors[i][0] for i in form.errors
]) if len(form.errors) > 0 else u'未知错误'
return HttpResponseBadRequest(json.dumps({
'code': 'false',
'msg': e,
'data': []
}),
content_type='application/json')
q = Auth(QINIU['access_key'], QINIU['secret_key'])
file_name = form.cleaned_data['name'] # 用户给的名字
staff_id = form.cleaned_data['staff']
remark = form.cleaned_data['remark']
data_file = request.FILES.get('file') # 不会form校验文件
data_file_lastname = request.FILES.get('file').name.split('.')[-1]
if not models.Staff.objects.filter(id=staff_id).exists():
return HttpResponseBadRequest(json.dumps({
'code': 'false',
'msg': '上传文件的员工不存在',
'data': []
}),
content_type='application/json')
key = ''.join(random.sample(string.ascii_letters + string.digits,
8)) # 随机八位字符
while models.File.objects.filter(qiniu_name=key): # 假如随机的八位字符已经被使用
key = ''.join(random.sample(string.ascii_letters + string.digits,
8)) # 新随机八位字符
token = q.upload_token(QINIU['bucket_name'], key, 3600)
base64_file = base64.b64encode(data_file.read())
qiniu_upload_url = "http://up-z2.qiniu.com/putb64/%s/key/%s/mimeType/%s" % \
(str(-1), urlsafe_base64_encode(key + '.' + data_file_lastname),
urlsafe_base64_encode(data_file_lastname))
headers = {
"Content-type": "application/octet-stream",
"Authorization": "UpToken " + token
}
requests.post(qiniu_upload_url, headers=headers, data=base64_file)
# resp = json.loads(requests.post(qiniu_upload_url, headers=headers, data=base64_file).content)
# hash = resp['hash'] # hash校验
# filename = resp['key']
file_obj = models.File()
file_obj.name = file_name + '.' + data_file_lastname
file_obj.staff = models.Staff.objects.get(id=staff_id)
file_obj.qiniu_name = key + '.' + data_file_lastname
file_obj.remark = remark
file_obj.save()
return HttpResponse(json.dumps({
'code': 'ok',
'msg': '上传文档成功',
'data': []
}),
content_type='application/json')
def file_url(self, host):
url = ['http://{0}/mkfile/{1}'.format(host, self.size)]
if self.mime_type:
url.append('mimeType/{0}'.format(urlsafe_base64_encode(self.mime_type)))
if self.key is not None:
url.append('key/{0}'.format(urlsafe_base64_encode(self.key)))
if self.params:
for k, v in self.params.items():
url.append('{0}/{1}'.format(k, urlsafe_base64_encode(v)))
url = '/'.join(url)
return url
def file_url(self, host):
url = ['http://{0}/mkfile/{1}'.format(host, self.size)]
if self.mime_type:
url.append('mimeType/{0}'.format(urlsafe_base64_encode(self.mime_type)))
if self.key is not None:
url.append('key/{0}'.format(urlsafe_base64_encode(self.key)))
if self.params:
for k, v in self.params.items():
url.append('{0}/{1}'.format(k, urlsafe_base64_encode(v)))
url = '/'.join(url)
return url
def fetch(self, url, key):
to = self.__entry(key)
resource = urlsafe_base64_encode(url)
cmd = 'http://{0}/fetch/{1}/to/{2}'.format(config.IO_HOST, resource,
to)
r = self.__post(cmd)
return _ret(r)
def mkbucketv2(self, bucket_name, region):
"""
创建存储空间
https://developer.qiniu.com/kodo/api/1382/mkbucketv2
Args:
bucket_name: 存储空间名
region: 存储区域
"""
bucket_name = urlsafe_base64_encode(bucket_name)
return self.__rs_do('mkbucketv2', bucket_name, 'region', region)
def set_bucketImagesource(self,
bucket_name,
resourceDomain,
resourceHost=None):
"""
设置 存储空间 镜像源
https://developer.qiniu.com/kodo/api/3966/bucket-image-source
Args:
bucket_name: 存储空间名
"""
resourceDomain = urlsafe_base64_encode(resourceDomain)
resourceHost = urlsafe_base64_encode(resourceHost)
if resourceHost is None or resourceHost == "":
url = "{0}/image/{1}/from/{2}".format(
config.get_default("default_uc_host"), bucket_name,
resourceDomain)
else:
url = "{0}/image/{1}/from/{2}/host/{3}".format(
config.get_default("default_uc_host"), bucket_name,
resourceDomain, resourceHost)
data = None
return http._post_with_qiniu_mac(url, data, self.auth)
def change_mime(self, bucket, key, mime):
"""修改文件mimeType:
主动修改指定资源的文件类型，具体规格参考：
http://developer.qiniu.com/docs/v6/api/reference/rs/chgm.html
Args:
bucket: 待操作资源所在空间
key: 待操作资源文件名
mime: 待操作文件目标mimeType
"""
resource = entry(bucket, key)
encode_mime = urlsafe_base64_encode(mime)
return self.__rs_do('chgm', resource, 'mime/{0}'.format(encode_mime))
def change_mime(self, bucket, key, mime):
"""修改文件mimeType:
主动修改指定资源的文件类型，具体规格参考：
http://developer.qiniu.com/docs/v6/api/reference/rs/chgm.html
Args:
bucket: 待操作资源所在空间
key: 待操作资源文件名
mime: 待操作文件目标mimeType
"""
resource = entry(bucket, key)
encode_mime = urlsafe_base64_encode(mime)
return self.__rs_do('chgm', resource, 'mime/{0}'.format(encode_mime))
def persistent_with_pfop(
self, perstr, fops
): #persistenet operations with fop sentence.the result save as 'origin key+perstr'
auth = self.q
bucket_name = self.bucket
saveas_key = self.key + perstr
entryuri = settings.QINIU_PRIVATE_BUCKET_NAME + ':' + saveas_key
entryuri = urlsafe_base64_encode(entryuri)
fops = fops + '|saveas/{}'.format(entryuri)
pfop = PersistentFop(auth,
bucket_name,
pipeline=settings.QINIU_PIPELINE)
ret, info = pfop.execute(self.key, [fops], 1)
return [ret, info]
def fetch(self, url, bucket, key=None):
"""抓取文件:
从指定URL抓取资源，并将该资源存储到指定空间中，具体规格参考：
http://developer.qiniu.com/docs/v6/api/reference/rs/fetch.html
Args:
url: 指定的URL
bucket: 目标资源空间
key: 目标资源文件名
Returns:
一个dict变量，成功返回NULL，失败返回{"error": "<errMsg string>"}
一个ResponseInfo对象
"""
resource = urlsafe_base64_encode(url)
to = entry(bucket, key)
return self.__io_do(bucket, 'fetch', resource, 'to/{0}'.format(to))
def file_url(self, host):
url = ['{0}/append/{1}/key/{2}'.format(host, self.offset, self.key)]
if self.size is None:
url.append('fsize/{0}'.format(-1))
else:
url.append('fsiez/{0}'.format(self.size))
if self.mime_type:
url.append('mimeType/{0}'.format(
urlsafe_base64_encode(self.mime_type)))
if self.crc:
url.append('crc32/{0}'.format(self.crc))
url = '/'.join(url)
return url
def persistent_with_pfop_nfop(
self, perstr,
fops): #persistent fop operation with nums of fop execute sentence
auth = self.q
bucket_name = self.bucket
foplist = []
for i in range(len(fops)):
saveas_key = self.key + perstr[i]
entryuri = settings.QINIU_PRIVATE_BUCKET_NAME + ':' + saveas_key
entryuri = urlsafe_base64_encode(entryuri)
fop = fops[i] + '|saveas/{}'.format(entryuri)
foplist.append(fop)
pfop = PersistentFop(auth,
bucket_name,
pipeline=settings.QINIU_PIPELINE)
ret, info = pfop.execute(self.key, foplist, 1)
return [ret, info]
def fetch(self, url, bucket, key=None):
"""抓取文件:
从指定URL抓取资源，并将该资源存储到指定空间中，具体规格参考：
http://developer.qiniu.com/docs/v6/api/reference/rs/fetch.html
Args:
url: 指定的URL
bucket: 目标资源空间
key: 目标资源文件名
Returns:
一个dict变量，成功返回NULL，失败返回{"error": "<errMsg string>"}
一个ResponseInfo对象
"""
resource = urlsafe_base64_encode(url)
to = entry(bucket, key)
return self.__io_do(bucket, 'fetch', resource, 'to/{0}'.format(to))
def change_status(self, bucket, key, status, cond):
"""修改文件的状态
修改文件的存储类型为可用或禁用：
Args:
bucket: 待操作资源所在空间
key: 待操作资源文件名
storage_type: 待操作资源存储类型，0为启用，1为禁用
"""
resource = entry(bucket, key)
if cond and isinstance(cond, dict):
condstr = ""
for k, v in cond.items():
condstr += "{0}={1}&".format(k, v)
condstr = urlsafe_base64_encode(condstr[:-1])
return self.__rs_do('chstatus', resource,
'status/{0}'.format(status), 'cond', condstr)
return self.__rs_do('chstatus', resource, 'status/{0}'.format(status))
def fetch(self, url, bucket, key=None):
"""抓取文件:
从指定URL抓取资源，并将该资源存储到指定空间中，具体规格参考：
http://developer.qiniu.com/docs/v6/api/reference/rs/fetch.html
Args:
url: 指定的URL
bucket: 目标资源空间
key: 目标资源文件名
Returns:
一个dict变量：
成功 返回{'fsize': <fsize int>, 'hash': <hash string>, 'key': <key string>, 'mimeType': <mimeType string>}
失败 返回 None
一个ResponseInfo对象
"""
resource = urlsafe_base64_encode(url)
to = entry(bucket, key)
return self.__io_do(bucket, 'fetch', resource, 'to/{0}'.format(to))
def block_url_v2(self, host, bucket_name):
encoded_object_name = urlsafe_base64_encode(
self.key) if self.key is not None else '～'
return '{0}/buckets/{1}/objects/{2}/uploads'.format(
host, bucket_name, encoded_object_name)
def fetch(self, url, bucket, key):
resource = urlsafe_base64_encode(url)
to = entry(bucket, key)
return self.__io_do('fetch', resource, 'to/{0}'.format(to))
def fetch(self, url, bucket, key):
resource = urlsafe_base64_encode(url)
to = entry(bucket, key)
return self.__io_do('fetch', resource, 'to/{0}'.format(to))
def change_mime(self, bucket, key, mime):
resource = entry(bucket, key)
encode_mime = urlsafe_base64_encode(mime)
return self.__rs_do('chgm', resource, 'mime/{0}'.format(encode_mime))
def change_mime(self, bucket, key, mime):
resource = entry(bucket, key)
encode_mime = urlsafe_base64_encode(mime)
return self.__rs_do('chgm', resource, 'mime/{0}'.format(encode_mime))
