コード例 #1
0
        private string GetSolictZipFile(List <KeyValuePair <string, DateTime> > docPaths)
        {
            if ((docPaths.Count == 1) &&
                (CommonContentAndFormatProvider.GetFileTypeFromName(docPaths[0].Key) == CommonContentType.ZIP))
            {
                AppendAuditLogEvent("Added document \"{0}\" to solicit request",
                                    docPaths[0].Key);
                return(docPaths[0].Key); // Single file and already zipped
            }
            ISettingsProvider  settingsProvider;
            ICompressionHelper compressionHelper;

            GetServiceImplementation(out settingsProvider);
            GetServiceImplementation(out compressionHelper);

            List <string> files = new List <string>(docPaths.Count);

            foreach (KeyValuePair <string, DateTime> pair in docPaths)
            {
                AppendAuditLogEvent("Added document \"{0}\" to solicit request",
                                    pair.Key);
                files.Add(pair.Key);
            }
            string tempFile = settingsProvider.NewTempFilePath(".zip");

            compressionHelper.CompressFiles(tempFile, files);
            return(tempFile);
        }
コード例 #2
0
        protected virtual string GetFileNameForRequestContent(FormattedPaginatedContentRequest request, PaginatedContentResult result)
        {
            StringBuilder sb = new StringBuilder();

            if (!string.IsNullOrEmpty(request.FlowName))
            {
                if (sb.Length > 0)
                {
                    sb.Append("_");
                }
                sb.Append(request.FlowName);
            }
            if (!string.IsNullOrEmpty(request.OperationName))
            {
                if (sb.Length > 0)
                {
                    sb.Append("_");
                }
                sb.Append(request.OperationName);
            }
            if (sb.Length > 0)
            {
                sb.Append("_");
            }
            sb.Append("Results");
            sb.Append(CommonContentAndFormatProvider.GetFileExtension(result.Content.Type));
            return(FileUtils.ReplaceInvalidFilenameChars(sb.ToString(), '_'));
        }
コード例 #3
0
 private bool CheckToCompressDocument(Document ioDocument)
 {
     if (_alwaysCompressDocumentContents)
     {
         if (!ioDocument.DontAutoCompress && !ioDocument.IsZipFile)
         {
             if (!string.IsNullOrEmpty(ioDocument.DocumentName))
             {
                 if ((ioDocument.DocumentName == "Node20.Report") ||
                     (ioDocument.DocumentName == "Node20.Error") ||
                     (ioDocument.DocumentName == "Node20.Original"))
                 {
                     // Don't compress these special files
                     return(false);
                 }
             }
             else
             {
                 ioDocument.DocumentName = Guid.NewGuid().ToString();
             }
             string originalDocumentName = ioDocument.DocumentName;
             string zipExtension         = CommonContentAndFormatProvider.GetFileExtension(CommonContentType.ZIP);
             ioDocument.DocumentName = Path.ChangeExtension(ioDocument.DocumentName, zipExtension);
             ioDocument.Type         = CommonContentType.ZIP;
             if (!CollectionUtils.IsNullOrEmpty(ioDocument.Content))
             {
                 ioDocument.Content = _compressionHelper.Compress(originalDocumentName, ioDocument.Content);
             }
             return(true);
         }
     }
     return(false);
 }
コード例 #4
0
        /// <summary>
        /// Add the input document to the node.
        /// </summary>
        public string AddDocument(string transactionId, CommonTransactionStatusCode status,
                                  string statusDetail, Document document)
        {
            if (CollectionUtils.IsNullOrEmpty(document.Content))
            {
                throw new ArgumentException(string.Format("Document does not contain any content: \"{0}\".", document));
            }
            string newId = IdProvider.Get();

            try
            {
                document.Id = newId;
                // First, attempt to save all the documents to the repository
                if (string.IsNullOrEmpty(document.DocumentId))
                {
                    document.DocumentId = newId;                        // If not specified, set this to DB id
                }
                if (string.IsNullOrEmpty(document.DocumentName))
                {
                    // If not specified, set this to DB id + extension
                    document.DocumentName =
                        Path.ChangeExtension(newId, CommonContentAndFormatProvider.GetFileExtension(document.Type));
                }
                CheckToCompressDocument(document);
                LOG.Debug("Saving document: \"{0}\"", document);
                _documentDao.CreateDocument(transactionId, status, statusDetail, document);
                _documentContentManager.SaveDocumentContent(transactionId, newId, document.Content, false);
                return(newId);
            }
            catch (Exception)
            {
                RollbackDocument(transactionId, newId);
                throw;
            }
        }
コード例 #5
0
        public virtual PaginatedContentResult ProcessQuery(string requestId)
        {
            string dataFilePath = GetDataFile(requestId, false);

            byte[]            data;
            CommonContentType?contentType = CommonContentType.XML;

            if (string.IsNullOrEmpty(dataFilePath))
            {
                data = new byte[0];
            }
            else
            {
                data        = File.ReadAllBytes(dataFilePath);
                contentType = CommonContentAndFormatProvider.GetFileTypeFromContent(data);
                if (!contentType.HasValue)
                {
                    contentType = CommonContentType.OTHER;
                }
            }

            PaginatedContentResult result = new PaginatedContentResult(_dataRequest.RowIndex, 0, true,
                                                                       contentType.Value, data);

            return(result);
        }
コード例 #6
0
ファイル: Client11.cs プロジェクト: hkbadeq/opennode2-dotnet
        /// <summary>
        /// NotifyDocument11
        /// </summary>
        /// <returns></returns>
        public string NotifyDocument11(string nodeEndpoint, string flow, string name, CommonContentType type, string content)
        {
            string transactionId =
                _requestor.Notify(Authenticate(), nodeEndpoint, flow, name,
                                  CommonContentAndFormatProvider.ConvertTo11Enum(type),
                                  content);

            return(transactionId);
        }
コード例 #7
0
        public string AddDocument(string transactionId, ExecuteContentResult result)
        {
            string docName =
                Path.ChangeExtension(Guid.NewGuid().ToString(),
                                     CommonContentAndFormatProvider.GetFileExtension(result.Content.Type));
            Document doc = new Document(docName, result.Content.Type, result.Content.Content);

            return(AddDocument(transactionId, result.Status, null, doc));
        }
コード例 #8
0
        public string AddDocument(string transactionId, CommonTransactionStatusCode status,
                                  string statusDetail, PaginatedContentResult result)
        {
            string docName =
                Path.ChangeExtension(Guid.NewGuid().ToString(),
                                     CommonContentAndFormatProvider.GetFileExtension(result.Content.Type));
            Document doc = new Document(docName, result.Content.Type, result.Content.Content);

            return(AddDocument(transactionId, status, statusDetail, doc));
        }
コード例 #9
0
 protected virtual void DoDownloadResponse(byte[] content, string documentName, CommonContentType contentType)
 {
     Response.ClearHeaders();
     Response.ClearContent();
     Response.AddHeader("Content-Disposition",
                        string.Format("attachment;filename=\"{0}\"", documentName));
     Response.AddHeader("Content-Length", content.Length.ToString());
     Response.ContentType = CommonContentAndFormatProvider.ConvertToMimeType(contentType);
     Response.BinaryWrite(content);
     Response.End();
 }
コード例 #10
0
        protected virtual string AddDocument(string transactionId, CommonTransactionStatusCode status,
                                             string statusDetail, string filePath, bool dontAutoCompress)
        {
            string   docName = Path.GetFileName(filePath);
            Document doc     =
                new Document(docName, CommonContentAndFormatProvider.GetFileTypeFromName(docName),
                             File.ReadAllBytes(filePath));

            doc.DontAutoCompress = dontAutoCompress;
            return(AddDocument(transactionId, status, statusDetail, doc));
        }
コード例 #11
0
        /// <summary>
        /// Add all the input documents to the node.
        /// </summary>
        public IList <string> AddDocuments(string transactionId, IList <Document> documents)
        {
            if (CollectionUtils.IsNullOrEmpty(documents))
            {
                return(null);
            }
            List <string> newDocumentIds = new List <string>(documents.Count);

            try {
                LOG.Debug("Saving documents");
                // First, generate ids for new documents
                foreach (Windsor.Node2008.WNOSDomain.Document document in documents)
                {
                    if (CollectionUtils.IsNullOrEmpty(document.Content))
                    {
                        throw new ArgumentException(string.Format("Document does not contain any content: \"{0}\".", document));
                    }
                    document.Id = IdProvider.Get();
                    if (string.IsNullOrEmpty(document.DocumentId))
                    {
                        document.DocumentId = document.Id;      // If not specified, set this to DB id
                    }
                    if (string.IsNullOrEmpty(document.DocumentName))
                    {
                        // If not specified, set this to DB id + extension
                        document.DocumentName =
                            Path.ChangeExtension(document.Id, CommonContentAndFormatProvider.GetFileExtension(document.Type));
                    }
                    newDocumentIds.Add(document.Id);
                    CheckToCompressDocument(document);
                }
                // Next, save the new documents to the DB
                _documentDao.CreateDocuments(transactionId, documents);
                // Finally, save document content to repository
                int index = 0;
                foreach (Windsor.Node2008.WNOSDomain.Document document in documents)
                {
                    LOG.Debug("Saving document: \"{0}\"", document);
                    _documentContentManager.SaveDocumentContent(transactionId, newDocumentIds[index++],
                                                                document.Content, false);
                }

                return(newDocumentIds);
            }
            catch (Exception) {
                RollbackDocuments(transactionId, newDocumentIds);
                throw;
            }
        }
コード例 #12
0
        protected virtual void ProcessWebServiceQuerySource(ScheduledItem scheduledItem, Activity activity,
                                                            string transactionId)
        {
            PartnerIdentity partner = _partnerManager.GetById(scheduledItem.SourceId);

            if (partner == null)
            {
                throw new ArgumentException(string.Format("Invalid partner id \"{0}.\"  Could not find partner for scheduled item \"{1}\".",
                                                          scheduledItem.TargetId, scheduledItem.Name));
            }

            string filePath = Path.Combine(SettingsProvider.TempFolderPath, GetResultFileName(scheduledItem));

            using (INodeEndpointClient client = GetNodeClient(partner, activity, scheduledItem.SourceEndpointUser))
            {
                CommonContentType type;
                try
                {
                    if (client.Version == EndpointVersionType.EN11)
                    {
                        type = client.Query(null, scheduledItem.SourceRequest, scheduledItem.GetTranformedSourceArgs(),
                                            0, -1, filePath);
                        _transactionManager.SetNetworkIdAndEndpointUserId(transactionId, transactionId, EndpointVersionType.EN11, partner.Url,
                                                                          scheduledItem.SourceRequest, null,
                                                                          null, scheduledItem.SourceEndpointUser);
                    }
                    else
                    {
                        type = client.Query(scheduledItem.SourceFlow, scheduledItem.SourceRequest,
                                            scheduledItem.GetTranformedSourceArgs(), 0, -1, filePath);
                        _transactionManager.SetNetworkIdAndEndpointUserId(transactionId, transactionId, EndpointVersionType.EN20, partner.Url,
                                                                          scheduledItem.SourceFlow, scheduledItem.SourceRequest, null,
                                                                          scheduledItem.SourceEndpointUser);
                    }
                }
                catch (Exception e)
                {
                    LogActivityError(activity, "Error returned from node endpoint: \"{0}\"", ExceptionUtils.GetDeepExceptionMessage(e));
                    throw;
                }
                filePath = FileUtils.ChangeFileExtension(filePath, CommonContentAndFormatProvider.GetFileExtension(type));
                DocumentManager.AddDocument(transactionId, CommonTransactionStatusCode.Processed, null, filePath);
            }
            LogActivity(activity, "Performed Query of partner \"{0}\" at url \"{1}\"", partner.Name, partner.Url);
        }
コード例 #13
0
        public virtual HttpResponseMessage Get([FromUri] QueryParameters parameters)
        {
            NamedOrAuthEndpointVisit visit = GetNamedOrAuthEndpointVisit(parameters);

            FormattedPaginatedContentRequest request = new FormattedPaginatedContentRequest();

            request.FlowName      = parameters.Dataflow;
            request.OperationName = parameters.Request;
            request.Paging        = new PaginationIndicator();
            request.Paging.Start  = parameters.RowId.HasValue ? parameters.RowId.Value : 0;
            request.Paging.Count  = parameters.MaxRows.HasValue ? parameters.MaxRows.Value : -1;
            request.Parameters    = parameters.ParseParams();
            request.ZipResults    = parameters.ZipResults;

            PaginatedContentResult resultSet = ServiceProvider.TransactionService.QueryEx(request, visit);

            if ((resultSet == null) || !resultSet.HasContent)
            {
                return(this.Request.CreateBadRequestResponse("No data was returned from the query."));
            }

            HttpResponseMessage responseMessage = new HttpResponseMessage();

            switch (resultSet.Content.Type)
            {
            case CommonContentType.XML:
            case CommonContentType.Flat:
            case CommonContentType.HTML:
                responseMessage.Content = new StringContent(resultSet.ConvertContentBytesToString());
                break;

            default:
                responseMessage.Content = new ByteArrayContent(resultSet.Content.Content);
                break;
            }

            responseMessage.Content.Headers.ContentType =
                new MediaTypeHeaderValue(CommonContentAndFormatProvider.ConvertToMimeType(resultSet.Content.Type));

            return(responseMessage);
        }
コード例 #14
0
ファイル: Client11.cs プロジェクト: hkbadeq/opennode2-dotnet
        public string[] DownloadByName(string flow, string transactionId, params string[] documentNames)
        {
            if (CollectionUtils.IsNullOrEmpty(documentNames))
            {
                throw new ArgumentException("documentNames cannot be empty");
            }
            Windsor.Node.Proxy11.WSDL.NodeDocument[] documents = new Windsor.Node.Proxy11.WSDL.NodeDocument[documentNames.Length];

            for (int i = 0; i < documentNames.Length; ++i)
            {
                Windsor.Node.Proxy11.WSDL.NodeDocument document = new Windsor.Node.Proxy11.WSDL.NodeDocument();
                document.name = documentNames[i];
                CommonContentType type = CommonContentAndFormatProvider.GetFileTypeFromName(document.name);
                if (type == CommonContentType.OTHER)
                {
                    type = CommonContentType.XML;   // Assume XML
                }
                document.type = type.ToString();
                documents[i]  = document;
            }
            _requestor.Download(Authenticate(), transactionId, flow, ref documents);
            return(SaveDownloadedDocuments(documents, null));
            //throw new InvalidOperationException("DownloadByName() is not a valid method call for Client11");
        }
コード例 #15
0
        /// <summary>
        /// ProcessSubmit
        /// </summary>
        public void ProcessSubmit(string transactionId)
        {
            ITransactionManager transactionManager;
            ISettingsProvider   settingsProvider;
            IDocumentManager    documentManager;

            AppendAuditLogEvent("Enter CopySubmitFilesToFolder.ProcessSubmit({0})",
                                transactionId);

            GetServiceImplementation(out transactionManager);
            GetServiceImplementation(out settingsProvider);
            GetServiceImplementation(out documentManager);

            string destinationFolderPath;

            if (!ConfigurationArguments.TryGetValue(DESTINATION_FOLDER_PATH, out destinationFolderPath))
            {
                throw new ArgumentException("DESTINATION_FOLDER_PATH configuration key not set");
            }
            if (!Directory.Exists(destinationFolderPath))
            {
                throw new DirectoryNotFoundException(string.Format("DESTINATION_FOLDER_PATH does not exist: {0}",
                                                                   destinationFolderPath));
            }
            bool createUsernameSubfolder = false;

            {
                string usernameSubfolder;
                if (ConfigurationArguments.TryGetValue(USE_USERNAME_SUBFOLDER, out usernameSubfolder) &&
                    !string.IsNullOrEmpty(usernameSubfolder))
                {
                    try
                    {
                        createUsernameSubfolder = bool.Parse(usernameSubfolder);
                    }
                    catch (Exception)
                    {
                        throw new FormatException(string.Format("Could not parse USE_USERNAME_SUBFOLDER true/false value: {0}",
                                                                usernameSubfolder));
                    }
                }
            }

            if (createUsernameSubfolder)
            {
                string username = transactionManager.GetTransactionUsername(transactionId);
                if (string.IsNullOrEmpty(username))
                {
                    throw new ArgumentException(string.Format("Could not username for transaction: {0}",
                                                              transactionId));
                }
                username = FileUtils.ReplaceInvalidFilenameChars(username, '_');
                destinationFolderPath = Path.Combine(destinationFolderPath, username);
            }

            AppendAuditLogEvent("DESTINATION_FOLDER_PATH: \"{0}\"", destinationFolderPath);

            IList <string> dbDocIds = transactionManager.GetAllUnprocessedDocumentDbIds(transactionId);

            if (!CollectionUtils.IsNullOrEmpty(dbDocIds))
            {
                if (!Directory.Exists(destinationFolderPath))
                {
                    Directory.CreateDirectory(destinationFolderPath);
                    AppendAuditLogEvent("Created folder DESTINATION_FOLDER_PATH: \"{0}\"",
                                        destinationFolderPath);
                }
                foreach (string dbDocId in dbDocIds)
                {
                    Document document = documentManager.GetDocument(transactionId, dbDocId, true);
                    string   docName;
                    if (!string.IsNullOrEmpty(document.DocumentName))
                    {
                        docName = document.DocumentName;
                    }
                    else if (!string.IsNullOrEmpty(document.DocumentId))
                    {
                        docName = document.DocumentName;
                    }
                    else
                    {
                        docName = dbDocId;
                    }
                    docName = FileUtils.ReplaceInvalidFilenameChars(docName, '_');
                    docName =
                        Path.ChangeExtension(docName, CommonContentAndFormatProvider.GetFileExtension(document.Type));
                    string copyPath = FileUtils.MakeUniqueIncrementalFilePath(destinationFolderPath, docName);
                    File.WriteAllBytes(copyPath, document.Content);
                    AppendAuditLogEvent("Copied file \"{0}\"", copyPath);
                    documentManager.SetDocumentStatus(transactionId, dbDocId, CommonTransactionStatusCode.Processed,
                                                      "Processed " + dbDocId);
                }
            }

            AppendAuditLogEvent("Exit CopySubmitFilesToFolder.ProcessSubmit({0})",
                                transactionId);
        }
コード例 #16
0
 public PaginatedContentResult(string filePath) :
     this(0, -1, true, CommonContentAndFormatProvider.GetFileTypeFromName(filePath),
          File.ReadAllBytes(filePath))
 {
 }
コード例 #17
0
        /// <summary>
        /// Download
        /// </summary>
        /// <param name="securityToken"></param>
        /// <param name="transactionId"></param>
        /// <param name="dataflow"></param>
        /// <param name="documents"></param>
        void INetworkNodeBinding.Download(string securityToken, string transactionId, string dataflow, ref NodeDocument[] documents)
        {
            Init();
            LOG.Debug("Download");

            if (string.IsNullOrEmpty(transactionId))
            {
                throw _service11Provider.FaultProvider.GetFault(EndpointVersionType.EN11, ENExceptionCodeType.E_InvalidParameter,
                                                                "NULL Transaction Id");
            }

            try
            {
                SoapContext res = HttpSoapContext.ResponseContext;

                LOG.Debug("Getting visit");
                NamedEndpointVisit visit = _service11Provider.VisitProvider.GetVisit(securityToken);

                ComplexContent content = new ComplexContent();
                if (!string.IsNullOrEmpty(dataflow))
                {
                    content.Flow = new OperationDataFlow(dataflow);
                }
                content.Transaction = new SimpleId(transactionId);

                LOG.Debug("Submitting: " + content);
                IList <Document> wnosDocs = _service11Provider.ContentService.Download(content, visit);


                List <NodeDocument> wsdlDocList = new List <NodeDocument>();

                if (!CollectionUtils.IsNullOrEmpty(wnosDocs))
                {
                    Dictionary <string, string> docIdList = new Dictionary <string, string>();

                    LOG.Debug("Spooling documents");
                    foreach (Document wnosDoc in wnosDocs)
                    {
                        NodeDocument doc = new NodeDocument();

                        doc.content = wnosDoc.Content;
                        doc.type    = CommonContentAndFormatProvider.ConvertTo11Enum(wnosDoc.Type);
                        doc.name    = wnosDoc.DocumentName;
                        LOG.Debug("   doc:" + doc);

                        DimeAttachment attachment = new DimeAttachment();
                        attachment.Stream     = new MemoryStream(doc.content);
                        attachment.TypeFormat = TypeFormatEnum.MediaType;
                        attachment.Type       = "application/x-gzip";
                        attachment.Id         = Guid.NewGuid().ToString();

                        //Add to the the xref filter collection
                        docIdList.Add(doc.name, attachment.Id);

                        res.Attachments.Add(attachment);
                        wsdlDocList.Add(doc);
                    }
                    //Output filter specific
                    res.Add("hrefs", docIdList);
                }

                documents = wsdlDocList.ToArray();
            }
            catch (Exception ex)
            {
                LOG.Error("Error while downloading", ex);
                throw _service11Provider.FaultProvider.GetFault(EndpointVersionType.EN11, ex);
            }
        }
コード例 #18
0
        /// <summary>
        /// Submit
        /// </summary>
        /// <param name="securityToken"></param>
        /// <param name="transactionId"></param>
        /// <param name="dataflow"></param>
        /// <param name="documents"></param>
        /// <returns></returns>
        string INetworkNodeBinding.Submit(string securityToken, string transactionId, string dataflow, NodeDocument[] documents)
        {
            Init();
            LOG.Debug("Submit");

            if (documents == null || documents.Length == 0)
            {
                throw _service11Provider.FaultProvider.GetFault(EndpointVersionType.EN11, ENExceptionCodeType.E_InvalidParameter,
                                                                "Document not provided");
            }

            SoapContext context = HttpSoapContext.RequestContext;

            bool useDimeAttachments = true;

            if (context == null ||
                context.Attachments == null ||
                context.Attachments.Count == 0)
            {
                bool allContentNull    = true;
                bool anyContentMissing = false;
                foreach (NodeDocument document in documents)
                {
                    if (document.content == null)
                    {
                        anyContentMissing = true;
                    }
                    else
                    {
                        allContentNull = false;
                    }
                }
                if (anyContentMissing)
                {
                    if (!allContentNull)
                    {
                        // Some documents contain content, some don't, what the heck is this???
                        throw _service11Provider.FaultProvider.GetFault(EndpointVersionType.EN11, ENExceptionCodeType.E_InvalidParameter,
                                                                        "Some documents do not contain any content.");
                    }
                    // All document content is null, attempt to locate all <content> elements in the xml itself
                    XmlNodeList nodeList = context.Envelope.Body.GetElementsByTagName("content");
                    if ((nodeList == null) || (nodeList.Count != documents.Length))
                    {
                        throw _service11Provider.FaultProvider.GetFault(EndpointVersionType.EN11, ENExceptionCodeType.E_InvalidParameter,
                                                                        "Could not locate the data content for the submitted documents.");
                    }
                    int index = 0;
                    foreach (NodeDocument document in documents)
                    {
                        XmlNode contentContentNode = nodeList[index++];
                        if (string.IsNullOrEmpty(contentContentNode.InnerXml))
                        {
                            throw _service11Provider.FaultProvider.GetFault(EndpointVersionType.EN11, ENExceptionCodeType.E_InvalidParameter,
                                                                            "Some documents do not contain any content.");
                        }
                        document.content = System.Convert.FromBase64String(contentContentNode.InnerXml);
                    }
                }
                useDimeAttachments = false;
            }
            else if (context.Attachments.Count != documents.Length)
            {
                throw _service11Provider.FaultProvider.GetFault(EndpointVersionType.EN11, ENExceptionCodeType.E_InvalidParameter,
                                                                "DIME attachment count does not equal to the number of documents.");
            }

            try
            {
                LOG.Debug("Getting visit");
                NamedEndpointVisit visit = _service11Provider.VisitProvider.GetVisit(securityToken);

                AsyncComplexContent content = new AsyncComplexContent();
                content.Documents   = new List <Document>();
                content.Flow        = new OperationDataFlow(dataflow);
                content.Transaction = new SimpleId(transactionId);

                int attachmentCounter = 0;

                LOG.Debug("Spooling documents");
                foreach (NodeDocument wsdlDoc in documents)
                {
                    Document doc = new Document();

                    doc.Content = useDimeAttachments ? GetContent(context.Attachments[attachmentCounter++].Stream) :
                                  wsdlDoc.content;
                    doc.Type         = CommonContentAndFormatProvider.Convert(wsdlDoc.type);
                    doc.DocumentId   = string.Empty;
                    doc.DocumentName = wsdlDoc.name;
                    LOG.Debug("   doc:" + doc);

                    content.Documents.Add(doc);
                }

                LOG.Debug("Submitting: " + content);
                TransactionStatus status = _service11Provider.ContentService.Submit(content, visit);

                LOG.Debug("Status: " + status);
                return(status.Id); //Status ID in this case is the transaction id
            }
            catch (Exception ex)
            {
                LOG.Error("Error while submitting", ex);
                throw _service11Provider.FaultProvider.GetFault(EndpointVersionType.EN11, ex);
            }
        }
コード例 #19
0
 public virtual string ConvertContentBytesToString()
 {
     return(CommonContentAndFormatProvider.ConvertContentBytesToString(_content));
 }