Example #1
0
        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);
        }
Example #2
0
        /// <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));
        }
Example #3
0
        /// <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);
            }
        }
Example #4
0
            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);
            }
Example #5
0
        /// <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);
        }
Example #6
0
        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;
        }
Example #7
0
        /// <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);
        }
Example #8
0
        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);
        }
Example #9
0
        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);
        }
Example #10
0
        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");
        }
Example #11
0
        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);
        }
Example #12
0
        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
                });
            }
        }
Example #14
0
        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 }));
        }
Example #15
0
 /// <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);
         }
     }
 }
Example #16
0
        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));
            }
        }
Example #17
0
        /// <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);
            }
        }
Example #18
0
        /// <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);
        }
Example #20
0
       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);
       }
Example #21
0
        /// <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);
        }
Example #22
0
        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));
        }
Example #23
0
        /// <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);
        }
Example #24
0
        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));
        }
Example #25
0
       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());
        }
Example #27
0
        /// <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);
        }
Example #28
0
        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);
        }
Example #30
0
        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);
        }
Example #31
0
        /// <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);
        }
Example #32
0
        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;
        }