API File Upload Demo

https://github.com/square9softworks/apifileuploaddemo
Admin
This Windows console application demonstrates how to upload a file to Square-9's GlobalSearch API,...
Tokens:3,404
Snippets:11
Trust Score:4.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### cURL Examples for Square 9 API Endpoints

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Provides command-line interface (cURL) examples for interacting with various Square-9 API endpoints. These examples demonstrate file uploads, retrieving license tokens, indexing documents with JSON payloads, and releasing licenses using different HTTP methods and authentication headers.

```bash
# Upload file
curl -X POST http://localhost/Square9Api/api/files/ \
  -u "S9UserName:S9Password" \
  -F "File=@tester.pdf"

# Response: {"files":[{"name":"uploaded-1234567890.pdf","isEmail":false}]}
```

```bash
# Get license token
curl -X GET http://localhost/Square9Api/api/licenses \
  -u "S9UserName:S9Password"

# Response: {"Token":"abc-123-xyz","Username":"S9UserName","DateCreated":"2025-10-14T10:30:00"}
```

```bash
# Index document
curl -X POST "http://localhost/Square9Api/api/dbs/1/archives/3?token=abc-123-xyz" \
  -u "S9UserName:S9Password" \
  -H "Content-Type: application/json" \
  -d '{
    "files": [{"name": "uploaded-1234567890.pdf"}],
    "fields": [
      {"name": "1", "value": "uploader1"},
      {"name": "2", "value": "uploader2"}
    ]
  }'
```

```bash
# Release license
curl -X DELETE "http://localhost/Square9Api/api/licenses/abc-123-xyz" \
  -u "S9UserName:S9Password"

# Response: HTTP 200 OK
```

--------------------------------

### Complete Workflow Example using C#

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Demonstrates an end-to-end workflow for file upload, license management, and document indexing using the Square9 API. This example integrates authentication, file posting, license acquisition and release, and document indexing in a production-ready pattern. It utilizes RestSharp for API communication and includes comprehensive error handling and cleanup.

```csharp
using System;
using System.Collections.Generic;
using RestSharp;
using S9APIUploadDemo.Models;

class Program
{
    static RestClient ApiClient = new RestClient("http://localhost/Square9Api");

    static void Main(string[] args)
    {
        // Configure authentication
        ApiClient.Authenticator = new HttpBasicAuthenticator("S9UserName", "S9Password");

        var databaseID = 1;
        var archiveID = 3;
        var localFileName = "tester.pdf";

        var token = "";
        try
        {
            // Step 1: Upload file
            string uploadedFileName = PostFile(localFileName);
            Console.WriteLine("File uploaded: " + uploadedFileName);

            // Step 2: Acquire license
            token = GetLicense();
            Console.WriteLine("License obtained: " + token);

            // Step 3: Prepare field data
            List<FieldItem> fieldData = new List<FieldItem>()
            {
                new FieldItem(1, "uploader1"),
                new FieldItem(2, "uploader2")
            };

            // Step 4: Index document
            IndexDocument(databaseID, archiveID, fieldData, uploadedFileName, token);

            Console.WriteLine(localFileName + " Uploaded Successfully.");
            Console.Read();
        }
        catch (Exception ex)
        {
            Console.WriteLine("Unable to upload file:\n " + ex.Message);
            Console.Read();
        }
        finally
        {
            // Step 5: Always release license
            if (!String.IsNullOrEmpty(token))
            {
                ReleaseLicense(token);
            }
        }
    }
}
```

--------------------------------

### GET /api/licenses

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Requests a license token from the GlobalSearch API required for performing document indexing and other operations.

```APIDOC
## GET /api/licenses

### Description
Requests a license token from the GlobalSearch API required for performing document indexing and other operations.

### Method
GET

### Endpoint
/api/licenses

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
// Assuming ApiClient is configured and authenticated
try
{
    string licenseToken = GetLicense();
    Console.WriteLine("License acquired: " + licenseToken);
}
catch (Exception ex)
{
    Console.WriteLine("License acquisition failed: " + ex.Message);
}
```

### Response
#### Success Response (200)
- **Token** (string) - The acquired license token.

#### Response Example
```json
{
  "Token": "abc123xyz-456-789-def"
}
```

#### Error Responses
- **401 Unauthorized**: If the user is not authorized.
- **400 Bad Request**: If the request is malformed.
- **404 Not Found**: If the license server cannot be reached.
```

--------------------------------

### C# Data Models for API Requests and Responses

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Defines C# classes for structuring data exchanged with the Square-9 API. Includes models for license tokens, field metadata, document indexing payloads, file references, field data, and upload responses. These models facilitate data serialization and deserialization.

```csharp
using System;
using System.Collections.Generic;

namespace S9APIUploadDemo.Models
{
    // License token response
    public class License
    {
        public string AuthServer { get; set; }
        public DateTime DateAccessed { get; set; }
        public DateTime DateCreated { get; set; }
        public string Domain { get; set; }
        public string IPAddress { get; set; }
        public int Reg { get; set; }
        public string Token { get; set; }
        public int Type { get; set; }
        public string Username { get; set; }
    }

    // Field metadata for indexing
    public class FieldItem
    {
        public int ID { get; set; }
        public string VAL { get; set; }

        public FieldItem(int id, string val)
        {
            ID = id;
            VAL = val;
        }
    }

    // Document indexing payload
    public class Indexer
    {
        public List<Field> fields { get; set; }
        public List<File> files { get; set; }

        public Indexer()
        {
            fields = new List<Field>();
            files = new List<File>();
        }
    }

    // File reference
    public class File
    {
        public String name;
        public File(String Name) { name = Name; }
    }

    // Field data
    public class Field
    {
        public String name;
        public String value;
        public Field(String Name, String Value)
        {
            this.name = Name;
            this.value = Value;
        }
    }

    // File upload response
    public class UploadedFile
    {
        public String name { get; set; }
        public Boolean isEmail { get; set; }
        public Dictionary<string, string> oEmailData { get; set; }
    }

    public class UploadedFileList
    {
        public List<UploadedFile> files { get; set; }
    }
}

// Usage example
var indexer = new Indexer();
indexer.files.Add(new File("server-file-123.pdf"));
indexer.fields.Add(new Field("1", "Document Type: Invoice"));
indexer.fields.Add(new Field("2", "Date: 2025-10-14"));
```

--------------------------------

### POST /api/files/

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Posts a file to the GlobalSearch API server and receives a server-side filename reference for subsequent indexing operations.

```APIDOC
## POST /api/files/

### Description
Posts a file to the GlobalSearch API server and receives a server-side filename reference for subsequent indexing operations.

### Method
POST

### Endpoint
/api/files/

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **File** (file) - Required - The file to upload.

### Request Example
```csharp
// Assuming ApiClient is configured and authenticated
string uploadedServerFileName = PostFile("C:\\Documents\\tester.pdf");
```

### Response
#### Success Response (200)
- **name** (string) - The server-side filename reference for the uploaded file.

#### Response Example
```json
{
  "files": [
    {
      "name": "tester.pdf"
    }
  ]
}
```
```

--------------------------------

### Configure GlobalSearch API File Upload (C#)

Source: https://github.com/square9softworks/apifileuploaddemo/blob/master/README.md

Demonstrates how to configure the connection details for uploading files to Square 9's GlobalSearch API within a C# console application. Users need to update the website target, authentication credentials (username and password), database ID, archive ID, and the local file name.

```csharp
var client = new RestClient("YOUR_GLOBALSEARCH_WEBSITE_URL");
client.Authenticator = new HttpBasicAuthenticator("S9UserName", "S9Password");

var databaseID = "YOUR_DATABASE_ID";
var archiveID = "YOUR_ARCHIVE_ID";
var localFileName = @"C:\Path\To\Your\File.pdf";
```

--------------------------------

### Index Document with Metadata using C#

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Indexes an uploaded file into a specific database and archive, including associated field metadata. Requires RestSharp and models for Indexer, File, and Field. Takes database ID, archive ID, field data, uploaded file name, and API token as input.

```csharp
using RestSharp;
using System.Collections.Generic;
using S9APIUploadDemo.Models;

static void IndexDocument(Int32 DatabaseID, Int32 ArchiveID, List<FieldItem> FieldData, String UploadedFileName, String Token)
{
    var indexData = new Indexer();
    indexData.files.Add(new File(UploadedFileName));

    if (FieldData != null && FieldData.Count > 0)
    {
        foreach (FieldItem field in FieldData)
        {
            var fieldItem = new Field(field.ID.ToString(), field.VAL);
            indexData.fields.Add(fieldItem);
        }
    }

    var request = new RestRequest("api/dbs/{db}/archives/{arch}?token={token}", Method.POST);
    request.AddParameter("token", Token, ParameterType.UrlSegment);
    request.AddParameter("db", DatabaseID, ParameterType.UrlSegment);
    request.AddParameter("arch", ArchiveID, ParameterType.UrlSegment);
    request.RequestFormat = DataFormat.Json;
    request.AddBody(indexData);

    var response = ApiClient.Execute(request);
    if (response.StatusCode != HttpStatusCode.OK)
    {
        throw new Exception("Unable to index document: " + response.Content);
    }
}

// Usage example
var databaseID = 1;  // Target database ID
var archiveID = 3;   // Target archive ID
var token = GetLicense();
List<FieldItem> fieldData = new List<FieldItem>()
{
    new FieldItem(1, "Invoice"),
    new FieldItem(2, "2025-10-14"),
    new FieldItem(3, "Customer-ABC")
};
string uploadedFileName = PostFile("invoice.pdf");

IndexDocument(databaseID, archiveID, fieldData, uploadedFileName, token);
```

--------------------------------

### Acquire GlobalSearch License Token

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Requests a license token from the GlobalSearch API using RestSharp, which is necessary for operations like document indexing. It takes no direct input but relies on the configured ApiClient. It returns the license token or throws an exception for various error conditions including unauthorized access or server not found.

```csharp
using RestSharp;
using System.Net;

static String GetLicense()
{
    var request = new RestRequest("api/licenses");
    var license = ApiClient.Execute<License>(request);

    if (license.StatusCode != HttpStatusCode.OK)
    {
        if (license.StatusCode == HttpStatusCode.Unauthorized)
        {
            throw new Exception("Unable to get a License: The passed user is Unauthorized.");
        }
        else if (license.StatusCode == HttpStatusCode.BadRequest)
        {
            throw new Exception("Unable to get a License: " + license.Content);
        }
        else if (license.StatusCode == HttpStatusCode.NotFound)
        {
            throw new Exception("Unable to get a License: Unable to connect to the license server, server not found.");
        }
        else
        {
            throw new Exception("Unable to get a License: " + license.Content);
        }
    }
    return license.Data.Token;
}

// Usage example
try
{
    string licenseToken = GetLicense();
    Console.WriteLine("License acquired: " + licenseToken);
    // Token format: "abc123xyz-456-789-def"
}
catch (Exception ex)
{
    Console.WriteLine("License acquisition failed: " + ex.Message);
}
```

--------------------------------

### C# RestSharp HTTP Basic Authentication Configuration

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Configures a RestSharp client to use HTTP Basic Authentication for Square-9 GlobalSearch API access. This involves setting the Authenticator property of the RestClient instance with either user credentials or Windows domain credentials. The generated header is automatically handled by RestSharp.

```csharp
using RestSharp;
using RestSharp.Authenticators;

// Configure API client with authentication
static RestClient ApiClient = new RestClient("http://your-server/Square9Api");

// Option 1: Square-9 user authentication
ApiClient.Authenticator = new HttpBasicAuthenticator("s9username", "s9password");

// Option 2: Windows domain authentication
ApiClient.Authenticator = new HttpBasicAuthenticator("DOMAIN\\username", "windowspassword");

// Usage example
var request = new RestRequest("api/licenses");
var response = ApiClient.Execute(request);
// Authentication header automatically added: "Authorization: Basic <base64-encoded-credentials>"
```

--------------------------------

### Upload File to GlobalSearch Server

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Posts a file to the GlobalSearch API server using RestSharp. It requires a file path as input and returns the server-side filename. Errors during upload will result in an exception. Dependencies include RestSharp and Newtonsoft.Json.

```csharp
using RestSharp;
using Newtonsoft.Json;
using S9APIUploadDemo.Models;

static RestClient ApiClient = new RestClient("http://localhost/Square9Api");

static String PostFile(String fileToPost)
{
    String uploadedFileName = String.Empty;

    var request = new RestRequest("api/files/", Method.POST);
    request.AddFile("File", fileToPost);
    var response = ApiClient.Execute(request);

    if (response.StatusCode != HttpStatusCode.OK)
    {
        throw new Exception("Unable to upload file: " + response.Content);
    }

    var uploadedFiles = JsonConvert.DeserializeObject<UploadedFileList>(response.Content);
    uploadedFileName = uploadedFiles.files[0].name;

    return uploadedFileName;
}

// Usage example
ApiClient.Authenticator = new HttpBasicAuthenticator("admin", "password123");
string uploadedServerFileName = PostFile("C:\\Documents\\tester.pdf");
Console.WriteLine("File uploaded as: " + uploadedServerFileName);
```

--------------------------------

### Release GlobalSearch License Token using C#

Source: https://context7.com/square9softworks/apifileuploaddemo/llms.txt

Releases a license token back to the license pool after operations complete. This function is crucial for proper resource management. It sends a request to the API to invalidate the token and requires the token string as input. Error handling is included for failed releases.

```csharp
using RestSharp;
using System.Net;

static void ReleaseLicense(String Token)
{
    var request = new RestRequest("api/licenses/" + Token);
    var response = ApiClient.Execute(request);

    if (response.ErrorException != null)
    {
        throw new Exception("Unable to release license token. ", response.ErrorException);
    }
    else if (response.StatusCode != HttpStatusCode.OK)
    {
        throw new Exception("Unable to release license token. " + response.Content);
    }
}

// Usage example with proper cleanup
string token = "";
try
{
    token = GetLicense();
    // Perform operations with token
    IndexDocument(1, 3, fieldData, "uploaded-file.pdf", token);
}
catch (Exception ex)
{
    Console.WriteLine("Operation failed: " + ex.Message);
}
finally
{
    if (!String.IsNullOrEmpty(token))
    {
        ReleaseLicense(token);
        Console.WriteLine("License released");
    }
}
```
Tokens:
Raw