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))