add new API

Author: stremovsky

README.md

@@ -5,20 +5,24 @@ A Java client library for interacting with the DatabunkerPro API. DatabunkerPro
 ## Features
 
 - Complete implementation of the DatabunkerPro API
-- User management (create, get, update, delete)
+- User management (create, get, update, delete, patch)
 - App data management
 - Legal basis and agreement management
 - Connector management
 - Group and role management
 - Policy management
-- Token management
+- Token management (including bulk operations)
 - Audit management
 - Tenant management
 - Session management
-- System configuration
+- System configuration and metrics
 - Bulk operations
+- Shared record management
+- Wrapping key generation for Shamir's Secret Sharing
+- Typed options classes for better type safety
 - Thread-safe implementation
 - Comprehensive test suite
+- Enhanced error handling
 
 ## Requirements
 
@@ -89,6 +93,24 @@ Then add the dependency to your `pom.xml`:
 </dependency>
 ```
 
+## New Features in Latest Version
+
+### Enhanced API Methods
+- **Wrapping Key Generation**: Generate wrapping keys from Shamir's Secret Sharing keys
+- **Typed Patch Operations**: Use structured `PatchOperation` objects for user updates
+- **Bulk Token Operations**: Create multiple tokens efficiently with typed options
+- **Shared Record Management**: Create and retrieve shared records with partner organizations
+
+### Improved Error Handling
+- Better HTTP status code handling
+- Enhanced error messages and logging
+- Graceful handling of API errors
+
+### Type Safety Improvements
+- Structured patch operations with `PatchOperation` class
+- Builder pattern for complex options
+- Enhanced error handling
+
 ## Usage
 
 ### Basic Setup
@@ -129,7 +151,13 @@ api.updateUser("email", "[email protected]", updates, null);
 
 // Delete a user
 api.deleteUser("email", "[email protected]", null);
-```
+
+// Patch a user with typed operations
+PatchOperation[] patchOps = {
+    new PatchOperation("replace", "/profile/name", "Jane Doe"),
+    new PatchOperation("add", "/profile/age", 25)
+};
+Map<String, Object> patchResult = api.patchUser("email", "[email protected]", patchOps, null);
 
 ### App Data Management
 
@@ -149,6 +177,53 @@ Map<String, Object> appData = api.getAppData("email", "[email protected]", "appna
 // Get system statistics
 Map<String, Object> stats = api.getSystemStats(null);
 System.out.println("System statistics: " + stats.get("stats"));
+
+// Generate wrapping key from Shamir's Secret Sharing keys
+Map<String, Object> wrappingKey = api.generateWrappingKey("key1", "key2", "key3", null);
+System.out.println("Generated wrapping key: " + wrappingKey.get("wrappingkey"));
+
+// Get system metrics
+Map<String, Object> metrics = api.getSystemMetrics(null);
+System.out.println("System metrics: " + metrics);
+```
+
+### Token Management
+
+```java
+// Create a single token
+TokenOptions tokenOptions = TokenOptions.builder()
+    .slidingtime("1d")
+    .finaltime("10d")
+    .unique(true)
+    .build();
+Map<String, Object> token = api.createToken("creditcard", "1234567890", tokenOptions, null);
+
+// Create multiple tokens in bulk
+Map<String, Object>[] tokenRecords = new Map[2];
+tokenRecords[0] = new HashMap<>();
+tokenRecords[0].put("tokentype", "creditcard");
+tokenRecords[0].put("record", "1234567890");
+tokenRecords[1] = new HashMap<>();
+tokenRecords[1].put("tokentype", "email");
+tokenRecords[1].put("record", "[email protected]");
+
+Map<String, Object> bulkTokens = api.createTokensBulk(tokenRecords, tokenOptions, null);
+```
+
+### Shared Record Management
+
+```java
+// Create a shared record
+SharedRecordOptions sharedOptions = SharedRecordOptions.builder()
+    .fields("name,email")
+    .partner("partner-org")
+    .appname("myapp")
+    .finaltime("100d")
+    .build();
+Map<String, Object> sharedRecord = api.createSharedRecord("email", "[email protected]", sharedOptions, null);
+
+// Get a shared record
+Map<String, Object> retrievedRecord = api.getSharedRecord("record-uuid", null);
 ```
 
 

src/main/java/org/databunker/DatabunkerproApi.java

@@ -23,6 +23,7 @@
 import org.databunker.options.RoleOptions;
 import org.databunker.options.TokenOptions;
 import org.databunker.options.PolicyOptions;
+import org.databunker.options.PatchOperation;
 import org.databunker.options.OptionsConverter;
 
 import java.io.IOException;
@@ -89,7 +90,21 @@ private Map<String, Object> makeRequest(String endpoint, Map<String, Object> dat
         try (CloseableHttpResponse response = httpClient.execute(request)) {
             HttpEntity entity = response.getEntity();
             String responseString = EntityUtils.toString(entity);
-            return objectMapper.readValue(responseString, Map.class);
+            Map<String, Object> result = objectMapper.readValue(responseString, Map.class);
+
+            if (response.getStatusLine().getStatusCode() < 200 || response.getStatusLine().getStatusCode() >= 300) {
+                if (result.containsKey("status")) {
+                    return result;
+                } else {
+                    throw new IOException(result.containsKey("message") ? 
+                        (String) result.get("message") : "API request failed");
+                }
+            }
+
+            return result;
+        } catch (Exception error) {
+            System.err.println("Error making request: " + error.getMessage());
+            throw new IOException("API request failed", error);
         }
     }
 
@@ -125,6 +140,9 @@ private byte[] rawRequest(String endpoint, Map<String, Object> data, Map<String,
         try (CloseableHttpResponse response = httpClient.execute(request)) {
             HttpEntity entity = response.getEntity();
             return EntityUtils.toByteArray(entity);
+        } catch (Exception error) {
+            System.err.println("Error making raw request: " + error.getMessage());
+            throw new IOException("Raw API request failed", error);
         }
     }
 
@@ -217,6 +235,24 @@ public Map<String, Object> patchUser(String mode, String identity, Map<String, O
         return makeRequest("UserPatch", data, requestMetadata);
     }
 
+    /**
+     * Patches a user with typed patch operations
+     *
+     * @param mode            User identification mode
+     * @param identity        User's identifier
+     * @param patch           Array of patch operations
+     * @param requestMetadata Optional request metadata
+     * @return The patched user information
+     * @throws IOException If an I/O error occurs
+     */
+    public Map<String, Object> patchUser(String mode, String identity, PatchOperation[] patch, Map<String, Object> requestMetadata) throws IOException {
+        Map<String, Object> data = new HashMap<>();
+        data.put("mode", mode);
+        data.put("identity", identity);
+        data.put("patch", patch);
+        return makeRequest("UserPatch", data, requestMetadata);
+    }
+
     public Map<String, Object> requestUserUpdate(String mode, String identity, Map<String, Object> profile, Map<String, Object> requestMetadata) throws IOException {
         Map<String, Object> data = new HashMap<>();
         data.put("mode", mode);
@@ -233,6 +269,24 @@ public Map<String, Object> requestUserPatch(String mode, String identity, Map<St
         return makeRequest("UserPatchRequest", data, requestMetadata);
     }
 
+    /**
+     * Requests a user patch with typed patch operations
+     *
+     * @param mode            User identification mode
+     * @param identity        User's identifier
+     * @param patch           Array of patch operations
+     * @param requestMetadata Optional request metadata
+     * @return The patch request result
+     * @throws IOException If an I/O error occurs
+     */
+    public Map<String, Object> requestUserPatch(String mode, String identity, PatchOperation[] patch, Map<String, Object> requestMetadata) throws IOException {
+        Map<String, Object> data = new HashMap<>();
+        data.put("mode", mode);
+        data.put("identity", identity);
+        data.put("patch", patch);
+        return makeRequest("UserPatchRequest", data, requestMetadata);
+    }
+
     public Map<String, Object> deleteUser(String mode, String identity, Map<String, Object> requestMetadata) throws IOException {
         Map<String, Object> data = new HashMap<>();
         data.put("mode", mode);
@@ -485,6 +539,8 @@ public Map<String, Object> updateLegalBasis(String brief, LegalBasisOptions opti
         return makeRequest("LegalBasisUpdate", data, requestMetadata);
     }
 
+
+
     public Map<String, Object> deleteLegalBasis(String brief, Map<String, Object> requestMetadata) throws IOException {
         Map<String, Object> data = new HashMap<>();
         data.put("brief", brief);
@@ -616,6 +672,8 @@ public Map<String, Object> updateProcessingActivity(String activity, ProcessingA
         return makeRequest("ProcessingActivityUpdate", data, requestMetadata);
     }
 
+
+
     public Map<String, Object> deleteProcessingActivity(String activity, Map<String, Object> requestMetadata) throws IOException {
         Map<String, Object> data = new HashMap<>();
         data.put("activity", activity);
@@ -940,7 +998,7 @@ public Map<String, Object> createToken(String tokentype, String record, Map<Stri
      * @return The created tokens information
      * @throws IOException If an I/O error occurs
      */
-    public Map<String, Object> createTokensBulk(Map<String, String>[] records, TokenOptions options, Map<String, Object> requestMetadata) throws IOException {
+    public Map<String, Object> createTokensBulk(Map<String, Object>[] records, TokenOptions options, Map<String, Object> requestMetadata) throws IOException {
         Map<String, Object> data = new HashMap<>();
         data.put("records", records);
         if (options != null) {
@@ -957,7 +1015,7 @@ public Map<String, Object> createTokensBulk(Map<String, String>[] records, Token
      * @return The created tokens information
      * @throws IOException If an I/O error occurs
      */
-    public Map<String, Object> createTokensBulk(Map<String, String>[] records, Map<String, Object> requestMetadata) throws IOException {
+    public Map<String, Object> createTokensBulk(Map<String, Object>[] records, Map<String, Object> requestMetadata) throws IOException {
         return createTokensBulk(records, null, requestMetadata);
     }
 
@@ -1152,6 +1210,8 @@ public Map<String, Object> updatePolicy(String policyid, PolicyOptions options,
         return makeRequest("PolicyUpdate", data, requestMetadata);
     }
 
+
+
     public Map<String, Object> getPolicy(String policyref, Map<String, Object> requestMetadata) throws IOException {
         Map<String, Object> data = new HashMap<>();
         if (policyref != null) {
@@ -1353,6 +1413,24 @@ public Map<String, Object> getSystemStats(Map<String, Object> requestMetadata) t
         return makeRequest("SystemGetSystemStats", null, requestMetadata);
     }
 
+    /**
+     * Generates a wrapping key from three Shamir's Secret Sharing keys
+     *
+     * @param key1            First Shamir secret sharing key
+     * @param key2            Second Shamir secret sharing key
+     * @param key3            Third Shamir secret sharing key
+     * @param requestMetadata Optional request metadata
+     * @return Generated wrapping key
+     * @throws IOException If an I/O error occurs
+     */
+    public Map<String, Object> generateWrappingKey(String key1, String key2, String key3, Map<String, Object> requestMetadata) throws IOException {
+        Map<String, Object> data = new HashMap<>();
+        data.put("key1", key1);
+        data.put("key2", key2);
+        data.put("key3", key3);
+        return makeRequest("SystemGenerateWrappingKey", data, requestMetadata);
+    }
+
     public Map<String, Object> getSystemMetrics(Map<String, Object> requestMetadata) throws IOException {
         String url = baseURL + "/metrics";
         HttpGet request = new HttpGet(url);