English (English) - Change language

Example of manual processing

This example shows how you can create an additional stage of manual data processing. For example, this stage can be used by the security department of your company. The security department may check and confirm sending of documents that meet specific conditions for further processing and reject documents that do not meet these conditions.

All confirmed documents are being accompanied by a set of bytes that imitate a digital signature.

You can download the project and materials here: UserStage.zip

The example code performs the following steps:

  • Configures the connection
  • Starts working with the project
  • Gets and processes the list of tasks
  • Processes each task at the service stage
  • Uploads the file to the server
  • Closes the session

To proceed with this example:

Start UserStageExample.sln in Visual Studio 2013 or newer versions:

1. Enter the URL of the Application Server.

2. Select an authentication type.

3. Click Login.

Configuring the connection

private const string FlexiHandlerPath = "/FlexiCapture12/Server/{0}API/v1/Soap"; // Path to FlexiCapture API
private const string FlexiCaptureAuthPart = "FCAuth/"; // Path to authenticate FlexiCapture
private const string UserStageProjectName = "UserStageExample"; // The name of the project used in this example
private const string UserStageName = "Service"; // The name of the service stage
// Creating new binding
var binding = new BasicHttpBinding();
// The size of a message it too small for FlexiCapture and we need to increase it
binding.MaxReceivedMessageSize = MessageSize;
// Selecting a new connection security mode depending on a protocol
binding.Security.Mode = serverUri.Scheme == Uri.UriSchemeHttps
   ? BasicHttpSecurityMode.Transport
   : BasicHttpSecurityMode.TransportCredentialOnly;
// Selecting the authentication method
binding.Security.Transport.ClientCredentialType = windowsAuth
   ? HttpClientCredentialType.Windows
   : HttpClientCredentialType.Basic;
// Selecting the path to API depending on the authentication method
var externalSuffix = windowsAuth ? string.Empty : FlexiCaptureAuthPart;
var remoteAddress = new EndpointAddress(new Uri(serverUri, string.Format(FlexiHandlerPath, externalSuffix)));
// Creating a SOAP client
_client = new FlexiCapture.FlexiCaptureWebServiceSoapClient(binding, remoteAddress);
// To authenticate FlexiCapture, specify a login and password
if (_client.ClientCredentials != null && !windowsAuth)
   _client.ClientCredentials.UserName.UserName = login;
   _client.ClientCredentials.UserName.Password = password;
Starting working with the project
// Open the session
_sessionId = _client.OpenSession(RoleType, WorkstationType);
var projectGuid = string.Empty;
// Find the required project
foreach (var project in _client.GetProjects())
   if (project.Name == UserStageProjectName)
      projectGuid = project.Guid;
if (string.IsNullOrEmpty(projectGuid))
   MessageBox.Show("The server does not contain the UserStageExample project which is needed for this example");
// Open the project
_projectId = _client.OpenProject(_sessionId, projectGuid);
// Find and save the service stage identifier
var stages = _client.GetProcessingStages(_projectId, 0, 0, UserStageName);
if (stages.Count != 1) throw new Exception("Invalid project");
   _serviceStageId = stages[0].Id;
// Find and save the external ID of the exceptions stage
stages = _client.GetProcessingStages(_projectId, 0, ExceptionStageType, string.Empty);
if (stages.Count != 1) throw new Exception("Invalid project");
   _exceptionsStageId = stages[0].ExternalId;

Getting and processing the list of tasks that are pending at the service stage

// Getting the list of tasks
var tasks = _client.GetAvailableTasksByStageId(_sessionId, _projectId,
new FlexiCapture.stageIds() { _serviceStageId }, false);
var result = new Dictionary<int, Task>();
if (tasks == null || tasks.Count == 0) return result;
foreach (var task in tasks)
   // For each task an object of the Task type is created
   var item = new Task
      Id = task.Id,
      BatchId = task.BatchId
   // Getting the list of documents of the task
   var documents = _client.GetTaskDocuments(task.Id);
   if (documents == null || documents.Count == 0) continue;
   foreach (var document in documents)
      // Loading the XML of the task
      var file = _client.LoadDocumentResult(_sessionId, document.BatchId, document.Id, "DocumentBody"); // "DocumentBody" - the name of the file that contains recognized data
      if (file == null || file.Bytes == null) continue;
      // Disassembling XML
      var doc = new Document(document.Id, XDocument.Load(new MemoryStream(file.Bytes)));
      // Saving the disassembled list of documents
      item.Documents.Add(document.Id, doc);
   result.Add(item.Id, item);

Sending the task for further processing

var ids = new FlexiCapture.docIds();
foreach (var rejectedDocument in rejectedDocuments)
if (ids.Count > 0)
   _client.CreateTask(_sessionId, batchId, _exceptionsStageId, 0, "Rejection reason", 0, ids, false);
_client.OpenBatch(_sessionId, batchId);
var hasDocuments = false;
   var uri = _client.Endpoint.Address.Uri.OriginalString.Replace("/API/v1/Soap", "/FileService/v1");
   foreach (var document in acceptedDocuments)
      hasDocuments = true;
      var buffer = new byte[SignatureSize]; // The size of the digital signature added to documents: 1024
      //DocumentAttachment: The attachment type (9 - document attachment)
      _client.SaveAttachment(_sessionId, DocumentAttachment, document.Id, batchId, _projectId, new FlexiCapture.File
         Bytes = buffer,
         Name = "Signature.dat"
      UploadTextFileToServer(new Uri(uri),
         document.GetXml(), 0, _sessionId, _projectId,
         batchId, 0, document.Id, 0, "DocumentBody"

Uploading the file to the server

Closing the session

_client.CloseProject(_sessionId, _projectId);

9/15/2020 9:42:43 AM

Please leave your feedback about this article