def get(self, request, format=None):
session = boto3.session.Session(
aws_access_key_id=COGNITO_ACCESS_KEY_ID,
aws_secret_access_key=COGNITO_SECRET_ACCESS_KEY,
region_name=AWS_REGION)
cognito = session.client("cognito-idp")
try:
if not 'AccessToken' in request.headers.keys():
raise cognito.exceptions.NotAuthorizedException(
auth_error_response(), "FileList")
user = cognito.get_user(AccessToken=request.headers['AccessToken'])
path = request.GET.get('path', None)
if not path:
user = cognito.admin_get_user(UserPoolId=COGNITO_USER_POOL_ID,
Username=user['Username'])
path = next((user_attribute
for user_attribute in user['UserAttributes']
if user_attribute['Name'] == 'custom:baseDirID'),
False)['Value']
queryset = File.objects.filter(path=path, deletedDate=None)
serializer = FileSerializer(queryset, many=True)
res = {
'totalSize': self.totalFileSize(user['Username']),
'fileList': serializer.data
}
return Response(res, status=status.HTTP_200_OK)
except ClientError as error:
return Response(
{
'error':
error.response['Error']['Code'],
'date':
error.response['ResponseMetadata']['HTTPHeaders']['date']
},
status=error.response['ResponseMetadata']['HTTPStatusCode'])
def update(self, request, pk=None, project_pk=None):
project = get_object_or_404(Project, pk=project_pk, owner=request.user)
instance = File.objects.get(pk=pk, project=project)
serializer = FileSerializer(instance, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data)
def create(self, request, project_pk=None):
project = get_object_or_404(Project, pk=project_pk, owner=request.user)
serializer = FileSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save(project=project)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def get(self, request, format=None):
session = boto3.session.Session(
aws_access_key_id=COGNITO_ACCESS_KEY_ID,
aws_secret_access_key=COGNITO_SECRET_ACCESS_KEY,
region_name=AWS_REGION)
cognito = session.client("cognito-idp")
try:
if not request.headers['AccessToken']:
raise cognito.exceptions.NotAuthorizedException
user = cognito.get_user(AccessToken=request.headers['AccessToken'])
queryset = File.objects.filter(author=user['Username'],
deletedDate__isnull=False)
serializer = FileSerializer(queryset, many=True)
res = {'fileList': serializer.data}
return Response(res, status=status.HTTP_200_OK)
except ClientError as error:
return Response(
{
'error':
error.response['Error']['Code'],
'date':
error.response['ResponseMetadata']['HTTPHeaders']['date']
},
status=error.response['ResponseMetadata']['HTTPStatusCode'])
def post(self, request):
file = request.FILES.get('file')
if not file:
return Response({"message": "File not found"}, status=417)
uploader = Uploader(file)
serializer = FileSerializer(data=uploader.get_data())
serializer.is_valid(raise_exception=True)
uploader.upload()
return Response(
FileSerializer(instance=serializer.create(serializer.data)).data,
status=201)
def get(self, request, pk=None, path=None, format=None):
file = get_object_by_id_or_path(model=File, pk=pk, path=path)
if has_access(file.parent, self.request.user):
serializer = FileSerializer(file)
return Response(serializer.data)
else:
raise exceptions.PermissionDenied()
def add_files(self, request, pk=None):
logger.debug('project add files')
project = self.get_object()
files = request.data.get('files', [])
folder = request.data.get('folder', None)
if folder:
try:
folder = Folder.objects.get(id=folder)
except Folder.DoesNotExist:
folder = None
description = request.data.get('description', '')
followers = request.data.get('followers', [])
files = File.objects.filter(id__in=files)
files.update(project=project, folder=folder,
description=description)
for f in files:
for user in User.objects.filter(id__in=followers):
logger.debug('user {0} follow file {1}'.format(user, f))
if not f.followers.filter(user=user).exists():
f.followers.create(user=user)
# Follower.objects.get_or_create(user=user, content_object=f)
# send notifications
notify.send(request.user, recipient=user,
verb='创建文件',
action_object=f,
description='用户{user}上传了文件{file}'.format(
user=request.user, file=f),
level='info')
s = FileSerializer(files, many=True)
return Response(s.data)
def upload(self, request, project_pk=None):
project = get_object_or_404(Project, pk=project_pk, owner=request.user)
f = request.FILES['file']
uploaded_file = File()
uploaded_file.project = project
uploaded_file.name = f.name
uploaded_file.code = ''.join(f.chunks())
uploaded_file.save()
serializer = FileSerializer(uploaded_file)
return Response(serializer.data)
def post(self, request, *args, **kwargs):
file_serializer = FileSerializer(data=request.data)
if file_serializer.is_valid():
file_serializer.save()
return Response(file_serializer.data,
status=status.HTTP_201_CREATED)
else:
return Response(file_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = FileSerializer(data=request.data, many=True)
serializer.is_valid(raise_exception=True)
array_index = request.data['encabezado'].split(',')
root = Path(".")
xls_path = root / "file" / str(request.data['file_xls'])
with open(xls_path, 'wb') as output:
pickle.dump(request.data['file_xls'], output, pickle.HIGHEST_PROTOCOL)
data = ScriptExcel.extractData(self, xls_path, request.data['key'], array_index)
elements = ScriptExcel.mapData(self, json.loads(data))
res = ScriptExcel.inserData(self, elements)
return Response(res)
def post(self, request, pk=None, path=None, format=None):
cur_dir = get_object_by_id_or_path(model=Directory, pk=pk, path=path)
self.request.data['parent'] = cur_dir.id
serializer = FileSerializer(data=self.request.data)
if has_access(cur_dir, self.request.user):
if serializer.is_valid():
serializer.save()
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
raise exceptions.PermissionDenied()
def post(self, request, format=None):
session = boto3.session.Session(
aws_access_key_id=COGNITO_ACCESS_KEY_ID,
aws_secret_access_key=COGNITO_SECRET_ACCESS_KEY,
region_name=AWS_REGION)
cognito = session.client("cognito-idp")
try:
if not 'AccessToken' in request.headers.keys():
raise cognito.exceptions.NotAuthorizedException(
auth_error_response(), "FolderUpload")
user = cognito.get_user(AccessToken=request.headers['AccessToken'])
dir_path = request.data['path']
if not dir_path:
user = cognito.admin_get_user(UserPoolId=COGNITO_USER_POOL_ID,
Username=user['Username'])
dir_path = next(
(user_attribute
for user_attribute in user['UserAttributes']
if user_attribute['Name'] == 'custom:baseDirID'),
False)['Value']
new_dir = {}
new_dir['name'] = request.data['name']
new_dir['path'] = dir_path
new_dir['isFile'] = request.data['isFile']
new_dir['author'] = request.data['author']
new_dir['fileSize'] = request.data['fileSize']
serializer = FileSerializer(data=new_dir)
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response(serializer.data,
status=status.HTTP_201_CREATED)
except ValidationError:
return Response(
{
'error': 'NoRequiredParameter',
'date': datetime.now()
},
status=status.HTTP_400_BAD_REQUEST)
except ClientError as error:
return Response(
{
'error':
error.response['Error']['Code'],
'date':
error.response['ResponseMetadata']['HTTPHeaders']['date']
},
status=error.response['ResponseMetadata']['HTTPStatusCode'])
def create(self, request, pk=None):
"""
"""
status_ = status.HTTP_500_INTERNAL_SERVER_ERROR
message = "Internal server error"
data = {}
try:
file = FileSerializer(data=request.data, fields=('_type', 'file'))
audio_info = mutagen.File(request.data.get("file")).info
payload = request.data
if not file.is_valid():
status_ = status.HTTP_400_BAD_REQUEST
message = "Bad Request"
return Response(data, data_status=status_, message=message)
payload['Duration'] = int(audio_info.length)
if request.data.get("_type") is not None:
if request.data.get("_type") == "PODCAST" and\
request.data.get("participants") is None:
payload['participants'] = ""
serilizer = self.get_serializer1(
request.data.get("_type")
)(data=payload, fields=payload.keys())
if serilizer.is_valid(raise_exception=True):
serilizer = serilizer.save()
serilizer.file.create(
file=request.data.get("file"),
_type=request.data.get("_type")
)
status_ = status.HTTP_200_OK
message = ""
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
print(str(e))
return Response(data, data_status=status_, message=message)
def mkdirRoot(self, username):
root = {
'isFile': False,
'author': username,
'name': username + "_root",
'path': "This is a root directory",
'fileSize': 0,
'starred': False
}
serializer = FileSerializer(data=root)
if serializer.is_valid(raise_exception=True):
serializer.save()
session = boto3.session.Session(
aws_access_key_id=COGNITO_ACCESS_KEY_ID,
aws_secret_access_key=COGNITO_SECRET_ACCESS_KEY,
region_name=AWS_REGION)
cognito = session.client("cognito-idp")
cognito.admin_update_user_attributes(
UserPoolId=COGNITO_USER_POOL_ID,
Username=username,
UserAttributes=[{
'Name': 'custom:baseDirID',
'Value': serializer.data['fid']
}])
def list(self, request, project_pk=None):
files = self.queryset.filter(project=project_pk)
serializer = FileSerializer(files, many=True,
context={"request": request})
return Response(serializer.data)
def post(self, request, format=None):
session = boto3.session.Session(
aws_access_key_id=COGNITO_ACCESS_KEY_ID,
aws_secret_access_key=COGNITO_SECRET_ACCESS_KEY,
region_name=AWS_REGION)
cognito = session.client("cognito-idp")
try:
if not 'AccessToken' in request.headers.keys():
raise cognito.exceptions.NotAuthorizedException(
auth_error_response(), "FileUpload")
user = cognito.get_user(AccessToken=request.headers['AccessToken'])
uploadedList = []
for idx, file in enumerate(request.FILES.getlist('file')):
uploadedFile = {}
file_path = str(request.data.getlist('path')[idx])
if not file_path:
user = cognito.admin_get_user(
UserPoolId=COGNITO_USER_POOL_ID,
Username=user['Username'])
file_path = next(
(user_attribute
for user_attribute in user['UserAttributes']
if user_attribute['Name'] == 'custom:baseDirID'),
False)['Value']
file.name = self.checkDuplicate(file.name, file_path)
uploadedFile['name'] = file.name
uploadedFile['path'] = file_path
uploadedFile['isFile'] = request.data.getlist('isFile')[idx]
uploadedFile['author'] = request.data.getlist('author')[idx]
uploadedFile['fileSize'] = request.data.getlist(
'fileSize')[idx]
serializer = FileSerializer(data=uploadedFile)
if serializer.is_valid(raise_exception=True):
serializer.save()
session = boto3.session.Session(
aws_access_key_id=S3_ACCESS_KEY_ID,
aws_secret_access_key=S3_SECRET_ACCESS_KEY,
region_name=AWS_REGION)
s3 = session.resource('s3')
s3.Bucket(S3_STORAGE_BUCKET_NAME).put_object(Key=str(
File.objects.get(name=file.name).pk),
Body=file)
uploadedList.append(serializer.data)
return Response(uploadedList, status=status.HTTP_201_CREATED)
except ValidationError:
return Response(
{
'error': 'NoRequiredParameter',
'date': datetime.now()
},
status=status.HTTP_400_BAD_REQUEST)
except ClientError as error:
return Response(
{
'error':
error.response['Error']['Code'],
'date':
error.response['ResponseMetadata']['HTTPHeaders']['date']
},
status=error.response['ResponseMetadata']['HTTPStatusCode'])
def test_invalid_file_serializer_without_id(self):
serializer = FileSerializer(
data=self.invalid_images_simple_upload_data_without_id)
self.assertFalse(serializer.is_valid())
upload_id_field = {'id'}
self.assertEqual(set(serializer.errors), upload_id_field)
def test_invalid_file_serializer_without_dict(self):
serializer = FileSerializer(
data=self.invalid_images_simple_upload_data_without_dict)
self.assertFalse(serializer.is_valid())
def test_file_serializer_multi_upload(self):
serializer = FileSerializer(data=self.valid_images_multi_upload_data)
self.assertTrue(serializer.is_valid())
upload_fields = ['id', 'filefield']
self.assertEqual(set(serializer.data.keys()), set(upload_fields))
