/// <summary>
        /// Delete file
        /// </summary>
        /// <param name="request">Request. <see cref="DeleteFileRequest" /></param>
        public void DeleteFile(DeleteFileRequest request)
        {
            // verify the required parameter 'path' is set
            if (request.Path == null)
            {
                throw new ApiException(400, "Missing required parameter 'path' when calling DeleteFile");
            }

            // create path and map variables
            var resourcePath = this.configuration.GetApiRootUrl() + "/assembly/storage/file/{path}";

            resourcePath = Regex
                           .Replace(resourcePath, "\\*", string.Empty)
                           .Replace("&amp;", "&")
                           .Replace("/?", "?");
            resourcePath = UrlHelper.AddPathParameter(resourcePath, "path", request.Path);
            resourcePath = UrlHelper.AddQueryParameterToUrl(resourcePath, "storageName", request.StorageName);
            resourcePath = UrlHelper.AddQueryParameterToUrl(resourcePath, "versionId", request.VersionId);

            var response = this.apiInvoker.InvokeApi(
                resourcePath,
                "DELETE",
                null,
                null,
                null);
        }
Example #2
0
        public override Task <DeleteFileReply> DeleteFile(DeleteFileRequest request, ServerCallContext context)
        {
            var result = new DeleteFileReply();

            SharePointFileManager _sharePointFileManager = new SharePointFileManager(_configuration);

            try
            {
                bool success = _sharePointFileManager.DeleteFile(request.ServerRelativeUrl).GetAwaiter().GetResult();

                if (success)
                {
                    result.ResultStatus = ResultStatus.Success;
                }
                else
                {
                    result.ResultStatus = ResultStatus.Fail;
                }
            }
            catch (SharePointRestException ex)
            {
                result.ResultStatus = ResultStatus.Fail;
                result.ErrorDetail  = $"ERROR in deleting file {request.ServerRelativeUrl}";
                _logger.LogError(ex, result.ErrorDetail);
            }
            catch (Exception e)
            {
                result.ResultStatus = ResultStatus.Fail;
                result.ErrorDetail  = $"ERROR in deleting file {request.ServerRelativeUrl}";
                _logger.LogError(e, result.ErrorDetail);
            }

            return(Task.FromResult(result));
        }
Example #3
0
        /// <summary>
        /// Deletes the specified file.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        ///   <c>DeleteFileResponse</c> with success status.
        /// </returns>
        public DeleteFileResponse Delete(DeleteFileRequest request)
        {
            if (request.Data == null || request.Id.HasDefaultValue())
            {
                return(new DeleteFileResponse {
                    Data = false
                });
            }

            var itemToDelete = repository
                               .AsQueryable <MediaFile>()
                               .Where(p => p.Id == request.Id)
                               .FirstOne();

            if (request.Data.Version > 0 && itemToDelete.Version != request.Data.Version)
            {
                throw new ConcurrentDataException(itemToDelete);
            }

            unitOfWork.BeginTransaction();

            mediaService.DeleteMedia(itemToDelete);

            unitOfWork.Commit();

            Events.MediaManagerEvents.Instance.OnMediaFileDeleted(itemToDelete);

            return(new DeleteFileResponse {
                Data = true
            });
        }
Example #4
0
        public RemoveFileResponse DeleteFileInCloud(string fileName)
        {
            var request  = new DeleteFileRequest(fileName);
            var response = _storageApi.DeleteFile(request);

            return(response);
        }
        public Stream Convert(Stream file, string fileName, string toFormat)
        {
            UploadFileRequest uploadFileRequest = new UploadFileRequest()
            {
                Path = fileName,
                File = file
            };

            CadCloudApi.UploadFile(uploadFileRequest);

            GetDrawingSaveAsRequest getDrawingSaveAsRequest = new GetDrawingSaveAsRequest()
            {
                Name         = fileName,
                OutputFormat = toFormat
            };

            var convertResult = CadCloudApi.GetDrawingSaveAs(getDrawingSaveAsRequest);

            DeleteFileRequest deleteFileRequest = new DeleteFileRequest()
            {
                Path = fileName
            };

            CadCloudApi.DeleteFile(deleteFileRequest);

            return(convertResult);
        }
Example #6
0
        /// <summary>
        /// Creates a commit that deletes a file in a repository.
        /// </summary>
        /// <param name="repositoryId">The Id of the repository</param>
        /// <param name="path">The path to the file</param>
        /// <param name="request">Information about the file to delete</param>
        public IObservable <Unit> DeleteFile(long repositoryId, string path, DeleteFileRequest request)
        {
            Ensure.ArgumentNotNullOrEmptyString(path, nameof(path));
            Ensure.ArgumentNotNull(request, nameof(request));

            return(_client.Repository.Content.DeleteFile(repositoryId, path, request).ToObservable());
        }
Example #7
0
        public async Task <IActionResult> DeleteFile(int fileId, CancellationToken token = default(CancellationToken))
        {
            var request = new DeleteFileRequest(fileId);
            await _commandProcessor.SendAsync(request, cancellationToken : token);

            return(new NoContentResult());
        }
Example #8
0
        public Stream Convert(Stream file, string fileName, string toFormat)
        {
            UploadFileRequest uploadFileRequest = new UploadFileRequest()
            {
                path = fileName,
                File = file
            };

            ImagingCloudApi.UploadFile(uploadFileRequest);

            var request = new ConvertImageRequest()
            {
                name   = fileName,
                format = toFormat
            };

            var convertResult = ImagingCloudApi.ConvertImage(request);

            DeleteFileRequest deleteFileRequest = new DeleteFileRequest()
            {
                path = fileName
            };

            ImagingCloudApi.DeleteFile(deleteFileRequest);

            return(convertResult);
        }
Example #9
0
        public static async Task <bool> removeFile(string path, string repo = "scdfiles")
        {
            try
            {
                var access_token = System.Environment.GetEnvironmentVariable("SCD_Access");
                var tokenAuth    = new Credentials(access_token);
                var client       = new GitHubClient(new ProductHeaderValue("marshmallouws"));
                client.Credentials = tokenAuth;

                // get sha for deletefile request
                var existingFile = await client.Repository.Content.GetAllContents("marshmallouws", repo, path);

                string sha = existingFile.ElementAt <RepositoryContent>(0).Sha;

                // create deletefilerequest
                var deleteFileRequest = new DeleteFileRequest("Remove testing installation", sha);
                // get repo
                var repositoryResponse = await client.Repository.Get("marshmallouws", repo);

                await client.Repository.Content.DeleteFile(repositoryResponse.Id, path, deleteFileRequest);

                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
        public RemoveFileResponse DeletePdf(string fileName)
        {
            var storageApi  = new StorageApi(_apiKey, _appSid);
            var request     = new DeleteFileRequest(fileName);
            var apiResponse = storageApi.DeleteFile(request);

            return(apiResponse);
        }
Example #11
0
        /// <summary>
        /// Creates a commit that deletes a file in a repository.
        /// </summary>
        /// <param name="owner">The owner of the repository</param>
        /// <param name="name">The name of the repository</param>
        /// <param name="path">The path to the file</param>
        /// <param name="request">Information about the file to delete</param>
        public IObservable <Unit> DeleteFile(string owner, string name, string path, DeleteFileRequest request)
        {
            Ensure.ArgumentNotNullOrEmptyString(owner, nameof(owner));
            Ensure.ArgumentNotNullOrEmptyString(name, nameof(name));
            Ensure.ArgumentNotNullOrEmptyString(path, nameof(path));
            Ensure.ArgumentNotNull(request, nameof(request));

            return(_client.Repository.Content.DeleteFile(owner, name, path, request).ToObservable());
        }
        public HttpResponseMessage DeleteFile(DeleteFileRequest request)
        {
            var groupId    = this.FindGroupId(this.Request);
            var moduleId   = this.Request.FindModuleId();
            var moduleMode = new SettingsManager(moduleId, groupId).Mode;

            ItemsManager.Instance.DeleteFile(request.FileId, moduleMode, groupId);
            return(this.Request.CreateResponse(HttpStatusCode.OK, new { Status = 0 }));
        }
        private void DeleteFile(string storageName, string path, string versionId = null)
        {
            var request = new DeleteFileRequest();

            request.Path      = path;
            request.Storage   = storageName;
            request.VersionId = versionId;
            var response = StorageApi.DeleteFile(request);

            Assert.AreEqual(200, response.Code);
        }
Example #14
0
 public async Task <IActionResult> Delete(DeleteFileRequest request)
 {
     try
     {
         return(Ok(new Success(await Mediator.Send(request), "Successfully")));
     }
     catch (Exception exception)
     {
         return(StatusCode((int)HttpStatusCode.InternalServerError, new InternalServerError(exception.Message)));
     }
 }
Example #15
0
        public void FileDeleteFileTest()
        {
            DeleteFileRequest request = new DeleteFileRequest();

            request.path      = Path.Combine(dataFolder, "TestFile.pdf");
            request.storage   = storageName;
            request.versionId = null;
            var response = FileApi.DeleteFile(request);

            Assert.AreEqual(200, response.Code);
        }
Example #16
0
 public void Post(DeleteFileRequest request)
 {
     this.MessageProducer3.Publish(new DeleteFileMqRequest()
     {
         FileDetails = new FileMeta()
         {
             FileName = request.FileDetails.FileName,
             ObjectId = request.FileDetails.ObjectId
         }
     });
 }
        public async Task <IActionResult> DeleteFileFromS3Async([FromBody] DeleteFileRequest request)
        {
            //TODO: Kullanıcının silmek istediği ID kendisine ait mi?

            //TODO: Delete From Database
            _imageService.DeleteImageByName(request.filename);

            string filename = request.filename;
            await _service.DeleteFileFroms3Async(filename, "hadibeoglum");

            return(Ok());
        }
Example #18
0
        public async Task <ActionResult> DeleteFile()
        {
            var assetClient = _mindSphereSdkService.GetAssetManagementClient();
            var request     = new DeleteFileRequest()
            {
                Id      = "fe81d2c22a9448eea41d0f460e5a5731",
                IfMatch = "0"
            };
            await assetClient.DeleteFileAsync(request);

            return(StatusCode(204));
        }
Example #19
0
        /// <summary>
        /// Deletes the specified file.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        ///   <c>DeleteFileResponse</c> with success status.
        /// </returns>
        public DeleteFileResponse Delete(DeleteFileRequest request)
        {
            if (request.Data == null || request.Id.HasDefaultValue())
            {
                return(new DeleteFileResponse {
                    Data = false
                });
            }

            var result = mediaService.DeleteMedia(request.Id, request.Data.Version, false);

            return(new DeleteFileResponse {
                Data = result
            });
        }
Example #20
0
        public DeleteFileResponse DeleteFile(DeleteFileRequest request)
        {
            DeleteFileResponse response = new DeleteFileResponse();

            try
            {
                response = FileManagerService.RemoteFileCommand(request).Action();
            }
            catch (Exception ex)
            {
                response.Code    = "0001";
                response.Message = ex.Message;
            }
            return(response);
        }
        public static void Run()
        {
            var apiInstance = new FileApi(Constants.GetConfig());

            try
            {
                var request = new DeleteFileRequest("one-page1.docx", Constants.MyStorage);

                apiInstance.DeleteFile(request);
                Console.WriteLine("Expected response type is Void: 'one-page1.docx' deleted.");
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception while calling FileApi: " + e.Message);
            }
        }
        public void TestDeleteFile()
        {
            // Arrange
            var testFile = TestFiles.Docx;
            var deleteRequest = new DeleteFileRequest {path = testFile.FullName};
            var existsRequest = new ObjectExistsRequest { path = testFile.FullName };
            var uploadRequest = new UploadFileRequest(testFile.FullName, GetTestFileStream(testFile));

            // Act & Assert
            FileApi.DeleteFile(deleteRequest);
            var response = StorageApi.ObjectExists(existsRequest);
            Assert.IsFalse(response.Exists);
            FileApi.UploadFile(uploadRequest);
            response = StorageApi.ObjectExists(existsRequest);
            Assert.IsTrue(response.Exists);
        }
Example #23
0
        /// <inheritdoc />
        public async Task DeleteFileAsync(
            string organizationName,
            string repositoryName,
            string path,
            DeleteFileRequest deleteFileRequest)
        {
            ArgumentCheck.StringIsNotNullOrWhiteSpace(organizationName, nameof(organizationName));
            ArgumentCheck.StringIsNotNullOrWhiteSpace(repositoryName, nameof(repositoryName));
            ArgumentCheck.StringIsNotNullOrWhiteSpace(path, nameof(path));

            await gitHubClient.Repository.Content.DeleteFile(
                organizationName,
                repositoryName,
                path,
                deleteFileRequest);
        }
        public static void Run()
        {
            var configuration = new Configuration(Common.MyAppSid, Common.MyAppKey);
            var apiInstance   = new FileApi(configuration);

            try
            {
                var request = new DeleteFileRequest("Annotationdocs1/one-page1.docx", Common.MyStorage);

                apiInstance.DeleteFile(request);
                Console.WriteLine("Expected response type is Void: 'Annotationdocs1/one-page1.docx' deleted.");
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception while calling FileApi: " + e.Message);
            }
        }
Example #25
0
        public async Task <bool> RemoveItemAsync(RootName root, FileSystemId target, bool recurse)
        {
            var context = await RequireContextAsync(root);

            var request = new DeleteFileRequest()
            {
                Path = target.Value
            };
            var link = await context.Client.Commands.DeleteAsync(request, CancellationToken.None);

            if (!await OperationProgressAsync(context, link))
            {
                throw new ApplicationException(string.Format(CultureInfo.CurrentCulture, Properties.Resources.OperationFailed, nameof(ICommandsClient.DeleteAsync)));
            }

            return(true);
        }
        public void TestDeleteFile()
        {
            string remoteFileName = "TestDeleteFile.docx";

            this.UploadFileToStorage(
                remoteDataFolder + "/" + remoteFileName,
                null,
                null,
                File.ReadAllBytes(LocalTestDataFolder + localFile)
                );

            var request = new DeleteFileRequest(
                path: remoteDataFolder + "/" + remoteFileName
                );

            this.WordsApi.DeleteFile(request);
        }
        public ActionResult DeleteFile(DeleteFileRequest req)
        {
            AzureFileService fileService = new AzureFileService(this._appSettings);
            var result = fileService.DeleteFile("files", req.FileName);

            if (result)
            {
                ResearchFile research = _context.ResearchFile.Where(
                    researchFile => researchFile.ProjectId == req.ProjectId &&
                    researchFile.FileName == req.FileName).FirstOrDefault();
                _context.ResearchFile.Remove(research);

                IList <ResearchFile> researchFileList = _context.ResearchFile.Where(
                    researchFile => researchFile.ProjectId == req.ProjectId).ToList();
                return(Ok(researchFileList));
            }
            return(NotFound());
        }
Example #28
0
        /// <summary>
        /// Delete file
        /// </summary>
        /// <param name="request">Request. <see cref="DeleteFileRequest" /></param>
        /// <returns><see cref=""/></returns>
        public void DeleteFile(DeleteFileRequest request)
        {
            // verify the required parameter 'path' is set
            if (request.path == null)
            {
                throw new ApiException(400, "Missing required parameter 'path' when calling DeleteFile");
            }

            // create path and map variables
            var resourcePath = this.configuration.GetApiRootUrl() + "/ocr/storage/file/{path}";

            resourcePath = Regex
                           .Replace(resourcePath, "\\*", string.Empty)
                           .Replace("&amp;", "&")
                           .Replace("/?", "?");
            resourcePath = UrlHelper.AddPathParameter(resourcePath, "path", request.path);
            resourcePath = UrlHelper.AddQueryParameterToUrl(resourcePath, "storageName", request.storageName);
            resourcePath = UrlHelper.AddQueryParameterToUrl(resourcePath, "versionId", request.versionId);

            try
            {
                var response = this.apiInvoker.InvokeApi <string>(
                    resourcePath,
                    "DELETE",
                    null,
                    null,
                    null);
                if (response != null)
                {
                    return;
                }

                return;
            }
            catch (ApiException ex)
            {
                if (ex.ErrorCode == 404)
                {
                    return;
                }

                throw;
            }
        }
Example #29
0
        /// <summary>
        /// Remove a specific file
        /// </summary>
        /// <param name="request">Request. <see cref="DeleteFileRequest" /></param>
        /// <returns><see cref="RemoveFileResponse"/></returns>
        public RemoveFileResponse DeleteFile(DeleteFileRequest request)
        {
            // verify the required parameter 'path' is set
            if (request.Path == null)
            {
                throw new ApiException(400, "Missing required parameter 'path' when calling DeleteFile");
            }

            // create path and map variables
            var resourcePath = this.configuration.GetApiRootUrl() + "/storage/file";

            resourcePath = Regex
                           .Replace(resourcePath, "\\*", string.Empty)
                           .Replace("&amp;", "&")
                           .Replace("/?", "?");
            resourcePath = UrlHelper.AddQueryParameterToUrl(resourcePath, "path", request.Path);
            resourcePath = UrlHelper.AddQueryParameterToUrl(resourcePath, "versionId", request.VersionId);
            resourcePath = UrlHelper.AddQueryParameterToUrl(resourcePath, "storage", request.Storage);

            try
            {
                var response = this.apiInvoker.InvokeApi(
                    resourcePath,
                    "DELETE",
                    null,
                    null,
                    null);
                if (response != null)
                {
                    return((RemoveFileResponse)SerializationHelper.Deserialize(response, typeof(RemoveFileResponse)));
                }

                return(null);
            }
            catch (ApiException ex)
            {
                if (ex.ErrorCode == 404)
                {
                    return(null);
                }

                throw;
            }
        }
        public override async Task <WopiResponse> DeleteFile(DeleteFileRequest deleteFileRequest)
        {
            var userId = WopiSecurity.GetIdentityNameFromToken(deleteFileRequest.AccessToken);
            var wopiFileRespository = new WopiFileRepository();
            var response            = await wopiFileRespository.DeleteFile(deleteFileRequest.ResourceId, userId);

            if (response == HttpStatusCode.NotFound)
            {
                return(deleteFileRequest.ResponseNotFound());
            }
            else if (response == HttpStatusCode.OK)
            {
                return(deleteFileRequest.ResponseOK());
            }
            else
            {
                return(deleteFileRequest.ResponseServerError(string.Format("Unknown HTTPStatusCode from WopiFileRepository.UpdateFileContent: {0}", response)));
            }
        }
        public IObservable<System.Reactive.Unit> DeleteFile(string owner, string name, string path, DeleteFileRequest request)
        {
            Ensure.ArgumentNotNullOrEmptyString(owner, "owner");
            Ensure.ArgumentNotNullOrEmptyString(name, "name");
            Ensure.ArgumentNotNullOrEmptyString(path, "path");
            Ensure.ArgumentNotNull(request, "request");

            return _client.Repository.Content.DeleteFile(owner, name, path, request).ToObservable();
        }
        /// <summary>
        /// Creates a commit that deletes a file in a repository.
        /// </summary>
        /// <param name="repositoryId">The Id of the repository</param>
        /// <param name="path">The path to the file</param>
        /// <param name="request">Information about the file to delete</param>
        public IObservable<Unit> DeleteFile(int repositoryId, string path, DeleteFileRequest request)
        {
            Ensure.ArgumentNotNullOrEmptyString(path, "path");
            Ensure.ArgumentNotNull(request, "request");

            return _client.Repository.Content.DeleteFile(repositoryId, path, request).ToObservable();
        }
Example #33
0
        /// <summary>
        /// Deletes the specified file.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        ///   <c>DeleteFileResponse</c> with success status.
        /// </returns>
        public DeleteFileResponse Delete(DeleteFileRequest request)
        {
            if (request.Data == null || request.Id.HasDefaultValue())
            {
                return new DeleteFileResponse { Data = false };
            }

            var result = mediaService.DeleteMedia(request.Id, request.Data.Version, false);

            return new DeleteFileResponse { Data = result };
        }
Example #34
0
        /// <summary>
        /// Deletes the specified file.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        ///   <c>DeleteFileResponse</c> with success status.
        /// </returns>
        public DeleteFileResponse Delete(DeleteFileRequest request)
        {
            if (request.Data == null || request.Id.HasDefaultValue())
            {
                return new DeleteFileResponse { Data = false };
            }

            var itemToDelete = repository
                .AsQueryable<MediaFile>()
                .Where(p => p.Id == request.Id)
                .FirstOne();

            if (request.Data.Version > 0 && itemToDelete.Version != request.Data.Version)
            {
                throw new ConcurrentDataException(itemToDelete);
            }

            unitOfWork.BeginTransaction();

            mediaService.DeleteMedia(itemToDelete);

            unitOfWork.Commit();

            Events.MediaManagerEvents.Instance.OnMediaFileDeleted(itemToDelete);

            return new DeleteFileResponse { Data = true };
        }