private Guid Upload(DocumentInfo document, Stream reader) { var chunkTotal = (int)Math.Ceiling((decimal)reader.Length / GetChunkSize()); var chunkSize = GetChunkSize(); var counter = 0; Guid oid = Guid.Empty; foreach (byte[] c in SplitIntoChunks(reader, chunkSize)) { var request = new UploadDocumentRequest { OidDocument = oid, DocumentName = document.DocumentName, Description = document.Description, Owner = document.Owner, Path = document.Path, Version = document.Version, DataField = c, ChunkNumber = counter++, ChunkTotal = chunkTotal, ChunkSize = chunkSize, MimeType = document.MimeType }; var response = _flowDocsService.UploadDocument(request); oid = response.OidDocument; } return(oid); }
/// <summary> /// Post /uploadDocument API call /// </summary> /// <param name="uploadDocumentRequest"></param> /// <returns> UploadDocumentResponse </returns> public UploadDocumentResponse UploadDocument(UploadDocumentRequest uploadDocumentRequest) { var jsonRequest = Util.JsonOperation.SerializeRequest(uploadDocumentRequest); var jsonResponse = _uploadDocument.Request(jsonRequest); return(JsonConvert.DeserializeObject <UploadDocumentResponse>(jsonResponse)); }
/// <summary> /// UplaodDocuments method to save document in IBM cloud /// </summary> /// <param name="documentMetadata"></param> /// <returns></returns> public async Task<(string status, Guid key)> UploadDocuments(DocumentMetadata documentMetadata) { string status = string.Empty; Guid key = Guid.Empty; using (var transferUtil = new RestTransferUtility(_restTransferUtilityOptions)) { var request = new UploadDocumentRequest { SourceSystem = documentMetadata.SourceSystem, Filename = documentMetadata.DocumentName, Name = documentMetadata.DocumentName, ContentType = documentMetadata.MimeType }; var response = await transferUtil.UploadAsync(request, new MemoryStream(documentMetadata.Document), new CancellationToken()); if (response.Errors != null) { status = response.Errors.Flatten().ToString(); } else { status = response.Status.ToString(); key = Guid.Parse(response.Key); } return (status, key); } }
public async Task <Result <Response> > UploadDocument(UploadDocumentRequest request) { const string api = "api/Factory/UploadDocument"; var response = await _owner.PostAsync <UploadDocumentRequest, Response>(api, request); return(response); }
/// <summary> /// Method to upload document to SPO library /// </summary> /// <param name="uploadDocumentRequest">Request Model format for Upload functionality</param> /// <param name="LoggerId">MessageId used for logging information</param> /// <returns></returns> public UploadDocumentResponse DDMSUpload(UploadDocumentRequest uploadDocumentRequest, string LoggerId) { UploadDocumentResponse uploadDocumentResponse = new UploadDocumentResponse(); try { Log.DebugFormat("In DDMSUpload method for MessageId - {0}", LoggerId); if (uploadDocumentRequest.DocumentId != Guid.Empty) { //if documentid is passed in request, an existing document will be updated uploadDocumentResponse = UpdateDocument(uploadDocumentRequest, LoggerId); } else { //if documentid is empty or not passed in request, a new document is uploaded uploadDocumentResponse = UploadDocument(uploadDocumentRequest, LoggerId); } Log.DebugFormat("Out of DDMSUpload method for MessageId - {0}", LoggerId); } catch (Exception e) { Log.ErrorFormat("Exception in DDMSUpload method :{0}", e.Message); uploadDocumentResponse.ErrorMessage = e.Message; } return(uploadDocumentResponse); }
public void UploadDocument_New_DocumentAlreadyExist_ReNameFile() { //File Name already exist-So renaming file var uploadDocumentRequest = new UploadDocumentRequest(); fileContent = Encoding.ASCII.GetBytes("Hello 2020....Bye Bye 2019"); uploadDocumentRequest.DocumentName = fileName; uploadDocumentRequest.DocumentContent = fileContent; uploadDocumentRequest.DealerNumber = Fixture.Create <Int32>().ToString(); uploadDocumentRequest.RequestUser = Fixture.Create <String>(); Fixture.Create <UploadDocumentRequest>(); var uploadDocumentResponse = Fixture.Create <UploadDocumentResponse>(); var ddmsUploadDocument = Substitute.For <DDMSUploadDocument>(); var uploadDocumentResponse2 = ddmsUploadDocument.DDMSUpload(uploadDocumentRequest, LoggerId); Assert.IsTrue(string.IsNullOrEmpty(uploadDocumentResponse2.ErrorMessage)); documentId = uploadDocumentResponse2.DocumentId; version = uploadDocumentResponse2.Version; }
/// <summary> /// Upload Chunk /// </summary> /// <param name="uow">Uow</param> /// <param name="oid">Oid</param> /// <param name="request">Request</param> private void UploadChunk(IFlowDocsUnitOfWork uow, Guid oid, UploadDocumentRequest request) { var dbId = uow.Attachments.FirstOrDefault(a => a.OidDocument == oid); int identity = request.ChunkNumber == 0 ? -1 : dbId.AttachmentId; CheckHash(uow, oid, request); SqlServerBlobStream blob = null; try { blob = new SqlServerBlobStream( _provider.ConnectionString, _provider.TableName, _provider.DataColumnName, _provider.PartialFlagColumnName, _provider.FileNameColumnName, request.DocumentName, _provider.MIMETypeColumnName, "", _provider.CreateProcedure, _provider.OpenProcedure, _provider.WriteProcedure, _provider.ReadProcedure, _provider.CleanupProcedure, _provider.RenameProcedure, _provider.StoreHashProcedure, _provider.DeleteProcedure, identity); blob.Seek(0, SeekOrigin.End); blob.Write(request.DataField, 0, request.DataField.Length); } finally { if (blob != null) { blob.Close(); //blob.Dispose(); } } UpdateDbForUpload(uow, oid, request, identity, blob.Identity); }
public async Task <string> UploadDocument(UploadDocumentRequest request) { string uploadPath = Path.Combine(DocumentStore, request.FileToUpload.FileName); using (var stream = System.IO.File.Create(uploadPath)) { await request.FileToUpload.CopyToAsync(stream); } return(uploadPath); }
private static HttpRequestMessage CreateUploadRequest(UploadDocumentRequest request) { var r = CreateRequest(HttpMethod.Post); r.Content = new MultipartFormDataContent("----------Upload") { { new StringContent(request.DocumentType.ToString()), "\"documentType\"" }, GetFileContent(request.Document) }; return(r); }
public void TestUpdateDocumentSuccess() { var client = CreateMockTestClientNullRequiredFieldsRequest("Mocks/marketpay/account/upload-document-success.json"); var account = new Account(client); var documentDetail = new DocumentDetail(accountHolderCode: "123456", filename: "stament.pdf", bankAccountUUID: "aaaaaaaa-7863-f943-4e3s-ffffffff", documentType: DocumentDetail.DocumentTypeEnum.BANKSTATEMENT); var uploadDocumentRequest = new UploadDocumentRequest(documentDetail: documentDetail, documentContent: new byte[1000]); var uploadDocumentResponse = account.UploadDocument(uploadDocumentRequest); Assert.AreEqual(uploadDocumentResponse.PspReference, "8815815165741111"); Assert.AreEqual(uploadDocumentResponse.AccountHolderCode, "TestAccountHolder8031"); }
private static HttpRequestMessage CreateUploadRequest(Uri requestUri, UploadDocumentRequest content, Headers headers) { var r = CreateRequest(HttpMethod.Post, requestUri, headers); r.Content = new MultipartFormDataContent($"----------Upload") { { new StringContent(content.DocumentType), "\"documentType\"" }, GetFileContent(content.Document) }; return(r); }
public string UploadDocument(string evaultId, string filePath) { string response = null; var result = new UploadDocumentRequest(evaultId, filePath).Execute(Api.Client); if (result.Status == 200) { response = result.Data; } return(response); }
public async Task <OperationResponse> UploadDocument(UploadDocumentRequest request) { try { _logger.LogInformation("Uploading documents with type {type} for client {clientId}", request.Type, request.ClientId); var profile = await _repository.GetOrCreateProfile(request.ClientId); if (string.IsNullOrEmpty(profile.ApplicantId)) { _logger.LogInformation("Creating applicant id for client {clientId}", request.ClientId); profile.ApplicantId = await _httpService.CreateApplicantId(request.ClientId); await _repository.UpdateProfile(profile, "Created applicant id", "automatic", null); } var existingDocumentId = profile.Documents.FirstOrDefault(t => t.Type == request.Type)?.DocumentId; var(documentId, file1, file2) = await _httpService.UploadDocument(profile.ApplicantId, request.FileSide1, request.FileSide2, request.Type, request.FileType, existingDocumentId); await using var context = new DatabaseContext(_dbContextOptionsBuilder.Options); var document = new KycDocument() { DocumentId = documentId, ClientId = profile.ClientId, Type = request.Type, FileId1 = file1, FileId2 = file2, Verified = false, DeclineReason = string.Empty }; await context.UpsertAsync(new[] { document }); context.AuditLogs.Add(KycAuditLog.Create(document, "Document upload", "automatic", null)); await context.SaveChangesAsync(); return(new OperationResponse() { IsSuccess = true }); } catch (Exception e) { _logger.LogError(e, "When uploading document for clientId {clientId}", request.ClientId); return(new OperationResponse() { IsSuccess = false, Error = e.Message }); } }
public virtual ActionResult IndexUpdateSignaturesUser(SignatureModel signature, HttpPostedFileBase file) { var messageStatus = MessageNotificationCodes.SaveDataSucessfully; bool updated = false; var filename = Path.GetFileName(file.FileName); var criteria = DoccumentObject.Criteria(DoccumentObject.SIGNATURE, filename, string.Empty, string.Empty, string.Empty); string trusteeList = DoccumentObject.TrusteeList(DoccumentObject.SIGNATURE); byte[] fileStream = new byte[file.ContentLength]; file.InputStream.Read(fileStream, 0, fileStream.Length); try { var request = new UploadDocumentRequest { AccessInformation = AccessInformationCategoryEnum.CONFIDENTIAL, FileName = file.FileName, FileStream = fileStream, OperationNumber = IDBContext.Current.Operation, BusinessAreaCode = BusinessAreaCodeEnum.BA_SIGNATURES, TrusteeList = trusteeList }; var createDocument = _documentManagementService.Upload(request); if (createDocument.IsValid) { signature.DocumentReference = createDocument.DocumentNumber; updated = Signatures.UpdateSignatureByUserSignatureId(signature); if (!updated) { messageStatus = MessageNotificationCodes.SaveDataFail; } } else { messageStatus = MessageNotificationCodes.SaveDataFail; } return(RedirectToAction("IndexSignatures", new { messageStatus = messageStatus })); } catch (Exception) { messageStatus = MessageNotificationCodes.SaveDataFail; } return(RedirectToAction("IndexSignatures", new { messageStatus = messageStatus })); }
/// <summary> /// Upload Chunk /// </summary> /// <param name="oid">Document Oid</param> /// <param name="request">Request</param> override protected void UploadChunk(Guid oid, UploadDocumentRequest request) { if (FlowDocsUnitOfWork != null) { UploadChunk(FlowDocsUnitOfWork, oid, request); } else { using (var uow = new FlowDocsUnitOfWork()) { UploadChunk(uow, oid, request); } } }
public IHttpActionResult UploadDocument([FromBody] UploadDocumentRequest uploadDocumentRequest) { Guid messageId; Dictionary <string, dynamic> keyValuePairs; //Retrieve the header parameters from request object RetrieveHeaders(out keyValuePairs, out messageId); UploadDocumentResponse uploadDocumentResponse = new UploadDocumentResponse(); try { Log.DebugFormat("In api/UploadDocument, before calling DDMSUpload method for MessageId - {0}", messageId.ToString()); // Upload or update the document to SPO library uploadDocumentResponse = ddmsUploadDocument.DDMSUpload(uploadDocumentRequest, messageId.ToString()); Log.DebugFormat("In api/UploadDocument, after calling DDMSUpload method for MessageId - {0}", messageId.ToString()); if (string.IsNullOrEmpty(uploadDocumentResponse.ErrorMessage)) { keyValuePairs.Add(HeaderConstants.ErrorCode, (int)HttpStatusCode.OK); keyValuePairs.Add(HeaderConstants.Status, HeaderValueConstants.Success); foreach (var field in keyValuePairs) { if (!string.IsNullOrEmpty(field.Value.ToString()) && !string.IsNullOrWhiteSpace(field.Value.ToString())) { HttpContext.Current.Response.Headers.Add(field.Key, field.Value.ToString()); } } return(Content(HttpStatusCode.OK, uploadDocumentResponse)); } //If file is not found during update if (uploadDocumentResponse.ErrorMessage == ErrorMessage.FileNotFound) { AddErrorResponseHeaders(keyValuePairs, (int)HttpStatusCode.NotFound, ErrorMessage.FileNotFound); return(Content(HttpStatusCode.NotFound, uploadDocumentResponse)); } else { AddErrorResponseHeaders(keyValuePairs, (int)HttpStatusCode.InternalServerError, uploadDocumentResponse.ErrorMessage); return(Content(HttpStatusCode.InternalServerError, uploadDocumentResponse)); } } catch (Exception ex) { Log.ErrorFormat("Error in api/UploadDocument DDMSUpload method for MessageId - {0} :{1}", messageId.ToString(), ex.Message); uploadDocumentResponse.ErrorMessage = ex.Message; AddErrorResponseHeaders(keyValuePairs, (int)HttpStatusCode.InternalServerError, uploadDocumentResponse.ErrorMessage); return(Content(HttpStatusCode.InternalServerError, uploadDocumentResponse)); } }
/// <summary> /// Check Hash /// </summary> /// <param name="uow">Uow</param> /// <param name="oid">Oid</param> /// <param name="request">Request</param> private void CheckHash(IFlowDocsUnitOfWork uow, Guid oid, UploadDocumentRequest request) { var hash = Md5Hash.CreateMd5Hash(request.DataField); if (hash != request.FileHash) { var attachs = uow.Attachments.Find(a => a.OidDocument == oid); foreach (var a in attachs) { uow.Attachments.Delete(a); } uow.Commit(); throw new Exception(Flow.Library.Properties.Resources.ER_HASH); } }
/// <summary> /// Update Db For Upload /// </summary> /// <param name="uow">Uow</param> /// <param name="oid">Oid</param> /// <param name="request">Request</param> /// <param name="DbId">DbId</param> /// <param name="blobId">blobId</param> private void UpdateDbForUpload(IFlowDocsUnitOfWork uow, Guid oid, UploadDocumentRequest request, int DbId, int blobId) { var newAttachment = uow.Attachments.FirstOrDefault(a => a.AttachmentId == DbId || a.AttachmentId == blobId); if (request.ChunkNumber == 0) { if (newAttachment != null) { newAttachment.OidDocument = oid; newAttachment.DateCreated = DateTime.Now; } } if (IsLastChunk(request)) { var prevDoc = ProcessUploadMode(uow, request); var newDocument = new Document { DateCreated = DateTime.Now, DateLastUpdated = DateTime.Now, Description = request.Description, DocumentName = request.DocumentName, OidDocument = oid, Owner = request.Owner, Path = request.Path, Version = request.Version, MimeType = request.MimeType, FileSize = request.FileSize, DocumentPrevious = prevDoc }; uow.Documents.Insert(newDocument); if (newAttachment != null) { newAttachment.Document = newDocument; } } try { uow.Commit(); } catch (Exception ex) { } }
private async Task <Uri> UploadAsync(string url, UploadDocumentRequest content, Headers headers = null, bool forceTokenRefresh = false) { headers ??= new Headers(); headers.Add("Authorization", $"Bearer {await GetTokenAsync(forceTokenRefresh).ConfigureAwait(false)}"); var response = await dwollaClient.UploadAsync(url, content, headers).ConfigureAwait(false); if (response.Error != null) { // Try to refresh the token once return(response.Error.Code == "ExpiredAccessToken" && !forceTokenRefresh ? await UploadAsync(url, content, forceTokenRefresh : true).ConfigureAwait(false) : throw new DwollaException(response.Error)); } return(response.Response.Headers.Location); }
public string UploadDocument(string fileName, string docType, string tradeKey, string tradingSystem, byte[] stream) { UploadDocumentRequest request = new UploadDocumentRequest { DocumentKey=tradeKey, DocumentType=docType, FeedType="Manual", FileName=fileName, ObjectFormatInd="Bytes", ObjectStream=stream , TradingSystemCode = tradingSystem }; UploadDocumentResponse response = _client.UploadDocument(request); return String.Format("Status:{0} ,URL :{1}",response.Status,response.URL); }
/// <summary> /// Upload /// </summary> /// <param name="document">Document</param> /// <param name="reader">Reader</param> /// <param name="mode">Mode</param> /// <returns>Guid</returns> private Guid Upload(DocumentInfo document, Stream reader, DocumentUploadMode mode) { var chunkTotal = (int)Math.Ceiling((decimal)reader.Length / GetChunkSize()); var chunkSize = GetChunkSize(); var counter = 0; Guid oid = Guid.Empty; foreach (byte[] c in SplitIntoChunks(reader, chunkSize)) { var request = new UploadDocumentRequest { OidDocument = oid, DocumentName = document.DocumentName, Description = document.Description, Owner = document.Owner, Path = document.Path, Version = document.Version, DataField = c, ChunkNumber = counter++, ChunkTotal = chunkTotal, ChunkSize = chunkSize, MimeType = document.MimeType, FileHash = Md5Hash.CreateMd5Hash(c), FileSize = reader.Length, Mode = mode, PreviousOid = document.PreviousOid }; UploadDocumentResponse response = null; if (_flowDocsService == null) { using (var docsProxy = new FlowDocsOperations()) { response = docsProxy.UploadDocument(request); } } else { response = _flowDocsService.UploadDocument(request); } oid = response.OidDocument; } return(oid); }
public string UploadDocument(string fileName, string docType, string tradeKey, string tradingSystem, byte[] stream) { UploadDocumentRequest request = new UploadDocumentRequest { DocumentKey = tradeKey, DocumentType = docType, FeedType = "Manual", FileName = fileName, ObjectFormatInd = "Bytes", ObjectStream = stream, TradingSystemCode = tradingSystem }; UploadDocumentResponse response = _client.UploadDocument(request); return(String.Format("Status:{0} ,URL :{1}", response.Status, response.URL)); }
/// <summary> /// AUTHOR: Ashok Kolwal /// COMPANY: VITRANA /// Version: 1.0 /// Description: This method is used for upload the document with it's content in documentum. /// Last Modified date: 11 Jul,2017 /// </summary> /// <param name="request">Local drive document input folder path</param> /// <returns>document and it's idfID</returns> public UploadDocumentResponse UploadDocuments(UploadDocumentRequest request) { UploadDocumentResponse response = new UploadDocumentResponse(); response.Status = 1; response.Message = "SUCCESS"; try { response.Result = new DocBrockerServiceUtility().UploadDoc(request.DocInputFolderPath); } catch (Exception ex) { response.Status = 0; response.Message = ServiceBase.GetExceptionMessage(ex); } return(response); }
public string UploadDocument(string fileName, string docType, string tradeKey, string tradingSystem, string formatInd, byte[] stream) { UploadDocumentRequest request = new UploadDocumentRequest { DocumentKey = tradeKey, DocumentType = docType, FeedType = "CONTRACTS",//fixed as this works for only the confirms now. ObjectFormatInd = formatInd, ObjectStream = stream, TradingSystemCode = tradingSystem, FileName = tradeKey + "_" + tradingSystem + "_" + docType + "." + formatInd//fileName, }; UploadDocumentResponse response = _client.UploadDocument(request); return(String.Format("Status:{0} ,URL :{1}", response.Status, response.URL)); }
public string UploadDocument(string fileName, string docType, string tradeKey, string tradingSystem, string formatInd, byte[] stream) { UploadDocumentRequest request = new UploadDocumentRequest { DocumentKey=tradeKey, DocumentType=docType, FeedType="CONTRACTS",//fixed as this works for only the confirms now. ObjectFormatInd = formatInd, ObjectStream=stream , TradingSystemCode = tradingSystem, FileName= tradeKey+"_"+tradingSystem+"_"+docType+ "."+formatInd//fileName, }; UploadDocumentResponse response = _client.UploadDocument(request); return String.Format("Status:{0} ,URL :{1}",response.Status,response.URL); }
public Response UploadDocument(UploadDocumentRequest request) { if (request == null) { throw new ArgumentNullException("request"); } byte[] byteArray = null; if (request.Data != null) { byteArray = System.Convert.FromBase64String(request.Data); } var cache = ServiceHelper.Cache; DocumentFactory.UploadDocument(cache, request.Uri, byteArray, 0, byteArray != null ? byteArray.Length : 0); return(new Response()); }
/// <summary> /// Method to validate if metadata is passed in request object /// </summary> /// <param name="uploadDocumentRequest">Request model for Upload Document</param> /// <returns></returns> private bool ValidateMetadata(UploadDocumentRequest uploadDocumentRequest) { bool validMetadata = false; try { //Checks if metadata is passed in request and returns a boolean value if (!string.IsNullOrEmpty(uploadDocumentRequest.DealerNumber) || !string.IsNullOrEmpty(uploadDocumentRequest.RequestUser)) { validMetadata = true; } } catch (Exception e) { validMetadata = false; } return(validMetadata); }
public void UploadDocument_UpdateMetaData_FileNotFound_Exception() { var uploadDocumentRequest = new UploadDocumentRequest(); uploadDocumentRequest.DocumentId = Fixture.Create <Guid>(); uploadDocumentRequest.DealerNumber = Fixture.Create <Int32>().ToString(); uploadDocumentRequest.RequestUser = Fixture.Create <String>(); Fixture.Create <UploadDocumentRequest>(); var uploadDocumentResponse = Fixture.Create <UploadDocumentResponse>(); var ddmsUploadDocument = Substitute.For <DDMSUploadDocument>(); var uploadDocumentResponse2 = ddmsUploadDocument.DDMSUpload(uploadDocumentRequest, LoggerId); Assert.IsTrue(uploadDocumentResponse2.ErrorMessage == ErrorMessage.FileNotFound); }
public void UploadDocument_MaxFileSizeReached() { var uploadDocumentRequest = new UploadDocumentRequest(); uploadDocumentRequest.DocumentName = Fixture.Create <String>(); uploadDocumentRequest.DocumentContent = Fixture.Create <byte[]>(); uploadDocumentRequest.DealerNumber = Fixture.Create <Int32>().ToString(); uploadDocumentRequest.RequestUser = Fixture.Create <String>(); Fixture.Create <UploadDocumentRequest>(); //var uploadDocumentResponse = Fixture.Create<UploadDocumentResponse>(); //var ddmsUploadDocument = Substitute.For<DDMSUploadDocument>(); //var uploadDocumentResponse2 = ddmsUploadDocument.DDMSUpload(uploadDocumentRequest); //Assert.IsTrue(uploadDocumentResponse2.ErrorMessage == ErrorMessage.MaxFileSizeContentReached); }
public void UploadDocument_UpdateDifferentExtension_Exception() { var uploadDocumentRequest = new UploadDocumentRequest(); uploadDocumentRequest.DocumentId = documentId; uploadDocumentRequest.DocumentName = Fixture.Create <String>() + ".pdf"; uploadDocumentRequest.DocumentContent = fileContent; uploadDocumentRequest.DealerNumber = Fixture.Create <Int32>().ToString(); uploadDocumentRequest.RequestUser = Fixture.Create <String>(); Fixture.Create <UploadDocumentRequest>(); var uploadDocumentResponse = Fixture.Create <UploadDocumentResponse>(); var ddmsUploadDocument = Substitute.For <DDMSUploadDocument>(); var uploadDocumentResponse2 = ddmsUploadDocument.DDMSUpload(uploadDocumentRequest, LoggerId); Assert.IsTrue(uploadDocumentResponse2.ErrorMessage == ErrorMessage.DifferentFileExtension); }
/// <summary> /// Upload Document. It calls the abstract method to perform the operation /// </summary> /// <param name="request">Request</param> /// <returns>Response</returns> public UploadDocumentResponse UploadDocument(UploadDocumentRequest request) { if (request.OidDocument != Guid.Empty && request.ChunkNumber == 0) { throw new ArgumentException("OidDocument should be empty"); } if (request.ChunkNumber > 0 && request.OidDocument == Guid.Empty) { throw new ArgumentException("OidDocument should not be empty"); } var response = new UploadDocumentResponse { OidDocument = request.OidDocument == Guid.Empty ? Guid.NewGuid() : request.OidDocument }; UploadChunk(response.OidDocument, request); return(response); }
public void UploadDocument_UpdateMetaData() { var uploadDocumentRequest = new UploadDocumentRequest(); uploadDocumentRequest.DocumentId = documentId; uploadDocumentRequest.DealerNumber = Fixture.Create <Int32>().ToString(); uploadDocumentRequest.RequestUser = Fixture.Create <String>(); Fixture.Create <UploadDocumentRequest>(); var uploadDocumentResponse = Fixture.Create <UploadDocumentResponse>(); var ddmsUploadDocument = Substitute.For <DDMSUploadDocument>(); var uploadDocumentResponse2 = ddmsUploadDocument.DDMSUpload(uploadDocumentRequest, LoggerId); Assert.IsTrue(string.IsNullOrEmpty(uploadDocumentResponse2.ErrorMessage)); documentId = uploadDocumentResponse2.DocumentId; version = uploadDocumentResponse2.Version; }