/// <summary>
        /// True if the user can access a given file
        /// </summary>
        /// <param name="entityName"></param>
        /// <param name="entityId"></param>
        /// <param name="documentType"></param>
        /// <param name="serverRelativeUrl"></param>
        /// <returns></returns>
        private async Task <bool> CanAccessEntityFile(string entityName, string entityId, string documentType, string serverRelativeUrl, bool isDelete = false)
        {
            var logUrl = WordSanitizer.Sanitize(serverRelativeUrl);

            var result = await CanAccessEntity(entityName, entityId, isDelete).ConfigureAwait(true);

            //get list of files for entity
            var hasFile = false;

            var fileExistsRequest = new FileExistsRequest
            {
                DocumentType      = documentType,
                EntityId          = entityId,
                EntityName        = entityName,
                FolderName        = await _dynamicsClient.GetFolderName(entityName, entityId).ConfigureAwait(true),
                ServerRelativeUrl = serverRelativeUrl
            };

            var hasFileResult = _fileManagerClient.FileExists(fileExistsRequest);

            if (hasFileResult.ResultStatus == FileExistStatus.Exist)
            {
                // Update modifiedon to current time
                hasFile = true;
            }
            else
            {
                _logger.LogError($"Unexpected error - Unable to validate file - {logUrl}");
            }

            return(result && hasFile);
        }
Пример #2
0
        public FileExistsResponse FileExists(FileExistsRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            FileProcessInfo processInfo;
            var             exists = FileUploadManager.FileExists(request.FileInfo, out processInfo);

            var result = new FileExistsResponse();

            result.Result    = exists;
            result.InProcess = processInfo;

            return(result);
        }
        public override Task <FileExistsReply> FileExists(FileExistsRequest request, ServerCallContext context)
        {
            var result = new FileExistsReply();

            SharePointFileManager _sharePointFileManager = new SharePointFileManager(_configuration);

            List <Interfaces.SharePointFileManager.FileDetailsList> fileDetailsList = null;

            try
            {
                fileDetailsList = _sharePointFileManager.GetFileDetailsListInFolder(GetDocumentTemplateUrlPart(request.EntityName), request.FolderName, request.DocumentType).GetAwaiter().GetResult();
                if (fileDetailsList != null)

                {
                    var hasFile = fileDetailsList.Any(f => f.ServerRelativeUrl == request.ServerRelativeUrl);

                    if (hasFile)
                    {
                        result.ResultStatus = FileExistStatus.Exist;
                    }
                    else
                    {
                        result.ResultStatus = FileExistStatus.NotExist;
                    }
                }
            }
            catch (SharePointRestException spre)
            {
                _logger.LogError(spre, "Error determining if file exists");
                result.ResultStatus = result.ResultStatus = FileExistStatus.Error;
                result.ErrorDetail  = "Error determining if file exists";
            }

            catch (Exception e)
            {
                result.ResultStatus = FileExistStatus.Error;
                result.ErrorDetail  = $"Error determining if file exists";
                _logger.LogError(e, result.ErrorDetail);
            }

            return(Task.FromResult(result));
        }
Пример #4
0
 public FileExistsResponse FileExists(FileExistsRequest request)
 {
     return(Channel.FileExists(request));
 }