Jhinno OpenAPI SDK for Java

https://github.com/yanlongqi/jhinno-openapi-java-sdk
Admin
A Java SDK that enables developers to easily integrate with Jhinno Appform APIs for managing...
Tokens:14,592
Snippets:38
Trust Score:4.6
Update:10 months ago
Show doc for...
Tokens:
Raw
### Manage Application Sessions with Java SDK

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

This Java code snippet demonstrates how to interact with the Jhinno OpenAPI Java SDK to manage application sessions. It covers listing applications, starting desktop sessions, reconnecting, sharing, transferring operator rights, disconnecting, and destroying sessions. Dependencies include the Jhinno SDK library. Input is configuration for session start, and output includes session IDs and URLs.

```java
import com.jhinno.sdk.openapi.api.app.JHAppApiExecution;
import com.jhinno.sdk.openapi.api.app.AppStartRequest;
import com.jhinno.sdk.openapi.api.app.AppStartedInfo;
import com.jhinno.sdk.openapi.api.app.SessionInfo;
import java.util.List;
import java.util.Arrays;

public class ApplicationSessionManager {

    private JHAppApiExecution appApi;

    public void demonstrateSessionManagement() throws Exception {
        // Get list of available applications
        List<AppInfo> availableApps = appApi.getAppList("jhadmin");
        System.out.println("Available applications:");
        for (AppInfo app : availableApps) {
            System.out.println("  " + app.getName() + " (" + app.getId() + ") - " + app.getOs());
        }

        // Configure application start parameters
        AppStartRequest request = new AppStartRequest();
        request.setStartNew(false); // Try to reuse existing session
        request.setCwd("$HOME/projects/simulation"); // Set working directory
        request.setWorkFile("model.cas"); // Open specific file
        request.setSessionType("desktop"); // Session type

        // Start Linux desktop application
        AppStartedInfo appInfo = appApi.desktopStart("jhadmin", "linux_desktop", request);
        String sessionId = appInfo.getDesktopId();
        System.out.println("Session started:");
        System.out.println("  Session ID: " + sessionId);
        System.out.println("  JH Client URL: " + appInfo.getJhappUrl());
        System.out.println("  Web Browser URL: " + appInfo.getWebSessionUrl());

        // List all active sessions for user
        List<SessionInfo> activeSessions = appApi.getDesktopList("jhadmin");
        System.out.println("\nActive sessions:");
        for (SessionInfo session : activeSessions) {
            System.out.println("  " + session.getName() + " [" + session.getId() + "]");
            System.out.println("    Status: " + session.getStatus());
            System.out.println("    Created: " + session.getCreateDate());
            System.out.println("    Last used: " + session.getLastUseTime());
        }

        // Get sessions by specific IDs
        List<SessionInfo> specificSessions = appApi.getDesktopsById("jhadmin",
            Arrays.asList("151", "152", "153"));

        // Reconnect to existing session
        AppStartedInfo reconnectInfo = appApi.connectJhapp("jhadmin", sessionId);
        System.out.println("\nReconnected to session: " + reconnectInfo.getWebSessionUrl());

        // Share session with other users (observers and interactors)
        List<String> observers = Arrays.asList("user1", "user2");
        List<String> interactors = Arrays.asList("user3");
        appApi.shareDesktop("jhadmin", sessionId, observers, interactors, false);
        System.out.println("Session shared with users");

        // Transfer operator rights to another user
        appApi.transferOperatorRight("jhadmin", sessionId, "user3");

        // Disconnect session (keeps session alive)
        appApi.disconnectSessionInfo("jhadmin", sessionId);
        System.out.println("Disconnected from session (session still running)");

        // Destroy session when done
        appApi.destroySession("jhadmin", sessionId);
        System.out.println("Session destroyed");

        // Batch operations - destroy multiple sessions
        List<String> sessionIds = Arrays.asList("151", "152");
        appApi.destroySessionByIds("jhadmin", sessionIds);
    }
}

```

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

### Manage Data Directories (Java)

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

Provides examples for managing data directories (spoolers) associated with jobs. It covers retrieving all data directories, fetching data for a specific job or multiple jobs, searching by name, scheduling automatic deletion (purging), and immediate deletion. This functionality relies on the JHDataApiExecution class and SpoolerDataInfo objects.

```java
import com.jhinno.sdk.openapi.api.data.JHDataApiExecution;
import com.jhinno.sdk.openapi.api.data.SpoolerDataInfo;
import java.util.*;

public class DataDirectoryManagement {

    private JHDataApiExecution dataApi;

    public void demonstrateDataOperations() throws Exception {
        String username = "jhadmin";

        // Get all data directories (spoolers) for user
        List<SpoolerDataInfo> allData = dataApi.getSpoolersData(username);
        System.out.println("Total data directories: " + allData.size());
        System.out.println("\nData directories:");

        for (SpoolerDataInfo data : allData) {
            System.out.println("  Job: " + data.getJobName() + " (ID: " + data.getJobId() + ")");
            System.out.println("    Data name: " + data.getDataName());
            System.out.println("    Data path: " + data.getDataPath());
            System.out.println("    Owner: " + data.getJobUser());
            System.out.println("    Working dir: " + data.getSubCwd());
            System.out.println("    Created: " + data.getCreateTime());
            System.out.println("    Project: " + data.getJobProject());
            System.out.println("    Classification: " + data.getConfidential());

            if (data.getDeleteTime() != null) {
                System.out.println("    Scheduled deletion: " + data.getDeleteTime());
            }
        }

        // Get data directory for specific job
        String jobId = "42";
        SpoolerDataInfo jobData = dataApi.getSpoolersDataById(username, jobId);
        if (jobData != null) {
            System.out.println("\nData directory for job " + jobId + ":");
            System.out.println("  Path: " + jobData.getDataPath());
            System.out.println("  Size: " + jobData.getDataName());
        }

        // Get data directories for multiple jobs
        List<String> jobIds = Arrays.asList("42", "43", "44");
        List<SpoolerDataInfo> multipleJobData = dataApi.getSpoolersDataByIds(username, jobIds);
        System.out.println("\nData directories for " + multipleJobData.size() + " jobs");

        // Search data directory by name
        SpoolerDataInfo namedData = dataApi.getSpoolersByName(username, "simulation_results_001");
        if (namedData != null) {
            System.out.println("\nFound data directory: " + namedData.getDataPath());
        }

        // Set expiration date for data directory (auto-deletion)
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, 30); // Expire in 30 days
        Date expirationDate = cal.getTime();
        dataApi.purgeSpooler(username, jobId, expirationDate);
        System.out.println("\nData directory will be deleted on: " + expirationDate);

        // Delete data directory immediately
        dataApi.deleteSpoolerData(username, "45");
        System.out.println("Data directory for job 45 deleted immediately");

        // Common workflow: Process completed job data
        SpoolerDataInfo completedJobData = dataApi.getSpoolersDataById(username, "50");
        if (completedJobData != null && completedJobData.getDataPath() != null) {
            System.out.println("\nProcessing job output from: " + completedJobData.getDataPath());
            // Use fileApi to access files in data directory
            // After processing, schedule for cleanup
            Calendar cleanup = Calendar.getInstance();
            cleanup.add(Calendar.DAY_OF_MONTH, 7);
            dataApi.purgeSpooler(username, "50", cleanup.getTime());
        }
    }
}
```

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

### GET /api/v1/custom/quota/{username}

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

Retrieves the quota information for a specific user, including disk usage, disk quota, maximum allowed jobs, and current job count.

```APIDOC
## GET /api/v1/custom/quota/{username}

### Description
Retrieves the quota information for a specific user.

### Method
GET

### Endpoint
/api/v1/custom/quota/{username}

#### Path Parameters
- **username** (string) - Required - The username for whom to retrieve quota information.

#### Request Body
None

### Response
#### Success Response (200)
- **diskQuota** (long) - The total disk quota allocated to the user.
- **diskUsed** (long) - The amount of disk space currently used by the user.
- **maxJobs** (int) - The maximum number of jobs the user is allowed to run concurrently.
- **currentJobs** (int) - The current number of jobs the user is running.

#### Response Example
```json
{
  "diskQuota": 10737418240,
  "diskUsed": 5368709120,
  "maxJobs": 10,
  "currentJobs": 3
}
```
```

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

### GET /api/v1/custom/reports

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

Generates a custom report based on specified criteria, including report type and a date range.

```APIDOC
## GET /api/v1/custom/reports

### Description
Generates a custom report based on specified criteria.

### Method
GET

### Endpoint
/api/v1/custom/reports

#### Path Parameters
None

#### Query Parameters
- **type** (string) - Required - The type of report to generate.
- **startDate** (Date) - Required - The start date for the report data.
- **endDate** (Date) - Required - The end date for the report data.

#### Request Body
None

### Response
#### Success Response (200)
- **reportId** (string) - The unique identifier for the generated report.
- **reportType** (string) - The type of the generated report.
- **data** (Map<String, Object>) - A map containing the report data.

#### Response Example
```json
{
  "reportId": "report-xyz789",
  "reportType": "daily_summary",
  "data": {
    "total_transactions": 150,
    "average_value": 75.50
  }
}
```
```

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

### Initialize SDK with AccessKey Authentication

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

Demonstrates how to initialize the Jhinno OpenAPI SDK for Java using AccessKey and SecretKey authentication. This includes setting up the API execution manager, configuring authentication details, and obtaining API executors for different resource types.

```APIDOC
## Initialize SDK with AccessKey Authentication

### Description
This section provides a Java code example for initializing the Jhinno OpenAPI SDK using AccessKey and SecretKey authentication. It covers setting up the `JHApiExecutionManage`, configuring authentication parameters like `AuthType`, `AccessKey`, `AccessKeySecret`, `TokenTimeout`, and `UsedServerTime`, and then obtaining specific API executors such as `JHAppApiExecution`, `JHFileApiExecution`, and `JHJobApiExecution`.

### Method
Java Code Example

### Endpoint
N/A (SDK Initialization)

### Parameters
N/A (SDK Initialization)

### Request Example
```java
import com.jhinno.sdk.openapi.JHApiExecutionManage;
import com.jhinno.sdk.openapi.JHApiRequestHandler;
import com.jhinno.sdk.openapi.AuthType;
import com.jhinno.sdk.openapi.api.app.JHAppApiExecution;
import com.jhinno.sdk.openapi.api.file.JHFileApiExecution;
import com.jhinno.sdk.openapi.api.job.JHJobApiExecution;

public class JhinnoSDKInitializer {

    public static void main(String[] args) {
        // Create API execution manager with server URL and request handler
        JHApiExecutionManage apiManager = new JHApiExecutionManage(
            "https://172.20.0.200",
            new JHApiRequestHandler() {
                @Override
                public String getCurrentUserName() {
                    return "admin"; // Return current username from session/context
                }
            }
        );

        // Configure authentication with AccessKey mode
        apiManager.configureApiExecution(execution -> {
            execution.setAuthType(AuthType.ACCESS_SECRET_MODE);
            execution.setAccessKey("8147c7470bfd4a27952fe750c6bc7cef");
            execution.setAccessKeySecret("899b13f590394c3daafc6468fed4b1df");
            execution.setTokenTimeout(60); // Token validity in minutes
            execution.setUsedServerTime(false); // Use local time for better performance
        });

        // Obtain API executors for different resources
        JHAppApiExecution appApi = apiManager.getApiExecution(JHAppApiExecution.class);
        JHFileApiExecution fileApi = apiManager.getApiExecution(JHFileApiExecution.class);
        JHJobApiExecution jobApi = apiManager.getApiExecution(JHJobApiExecution.class);

        // Test connection by getting app list
        try {
            System.out.println("Available applications: " + appApi.getAppList().size());
            System.out.println("SDK initialized successfully!");
        } catch (Exception e) {
            System.err.println("Failed to connect: " + e.getMessage());
        }
    }
}
```

### Response
#### Success Response (Initialization)
Successful initialization of the SDK, allowing subsequent API calls.

#### Response Example
```
SDK initialized successfully!
```
```

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

### Initialize Jhinno SDK with AccessKey Authentication in Java

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

Demonstrates how to initialize and configure the Jhinno OpenAPI SDK using AccessKey and SecretKey for authentication. It sets up the API execution manager, configures authentication parameters like token timeout and server time usage, and obtains API executors for different services (apps, files, jobs). Includes a basic test to verify SDK initialization by retrieving the app list.

```java
import com.jhinno.sdk.openapi.JHApiExecutionManage;
import com.jhinno.sdk.openapi.JHApiRequestHandler;
import com.jhinno.sdk.openapi.AuthType;
import com.jhinno.sdk.openapi.api.app.JHAppApiExecution;
import com.jhinno.sdk.openapi.api.file.JHFileApiExecution;
import com.jhinno.sdk.openapi.api.job.JHJobApiExecution;

public class JhinnoSDKInitializer {

    public static void main(String[] args) {
        // Create API execution manager with server URL and request handler
        JHApiExecutionManage apiManager = new JHApiExecutionManage(
            "https://172.20.0.200",
            new JHApiRequestHandler() {
                @Override
                public String getCurrentUserName() {
                    return "admin"; // Return current username from session/context
                }
            }
        );

        // Configure authentication with AccessKey mode
        apiManager.configureApiExecution(execution -> {
            execution.setAuthType(AuthType.ACCESS_SECRET_MODE);
            execution.setAccessKey("8147c7470bfd4a27952fe750c6bc7cef");
            execution.setAccessKeySecret("899b13f590394c3daafc6468fed4b1df");
            execution.setTokenTimeout(60); // Token validity in minutes
            execution.setUsedServerTime(false); // Use local time for better performance
        });

        // Obtain API executors for different resources
        JHAppApiExecution appApi = apiManager.getApiExecution(JHAppApiExecution.class);
        JHFileApiExecution fileApi = apiManager.getApiExecution(JHFileApiExecution.class);
        JHJobApiExecution jobApi = apiManager.getApiExecution(JHJobApiExecution.class);

        // Test connection by getting app list
        try {
            System.out.println("Available applications: " + appApi.getAppList().size());
            System.out.println("SDK initialized successfully!");
        } catch (Exception e) {
            System.err.println("Failed to connect: " + e.getMessage());
        }
    }
}

```

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

### Manage Directories and Files with Jhinno Java SDK

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

This snippet demonstrates creating directories (with and without force), creating empty files, compressing directories to ZIP archives (with optional password protection), and decompressing archives to specified locations. It utilizes the JHFileApiExecution class from the Jhinno SDK.

```java
import com.jhinno.sdk.openapi.api.file.JHFileApiExecution;
import com.jhinno.sdk.openapi.api.file.FileInfo;
import com.jhinno.sdk.openapi.api.file.Confidential;
import java.util.List;

public class DirectoryAndCompressionExample {

    private JHFileApiExecution fileApi;

    public void demonstrateDirectoryOperations() throws Exception {
        String username = "jhadmin";

        // Create nested directories with force flag
        String projectDir = fileApi.mkdir(username, "$HOME/projects/simulation/data", true);
        System.out.println("Created directory: " + projectDir);

        // Create directory without force (fails if exists)
        try {
            String newDir = fileApi.mkdir(username, "$HOME/temp");
            System.out.println("Created directory: " + newDir);
        } catch (Exception e) {
            System.err.println("Directory creation failed: " + e.getMessage());
        }

        // Create empty file
        String emptyFile = fileApi.mkFile(username, "$HOME/temp/placeholder.txt");
        System.out.println("Created empty file: " + emptyFile);

        // Compress directory to ZIP archive
        fileApi.compress(username, "$HOME/projects/simulation",
            "$HOME/archives/simulation_backup.zip", null);
        System.out.println("Directory compressed to simulation_backup.zip");

        // Compress with password protection
        fileApi.compress(username, "$HOME/projects/confidential",
            "$HOME/archives/confidential.zip", "SecurePass123");

        // Uncompress archive to target directory
        fileApi.uncompress(username, "$HOME/archives/simulation_backup.zip",
            "$HOME/restored/simulation/", false, null);
        System.out.println("Archive extracted to $HOME/restored/simulation/");

        // Uncompress password-protected archive with overwrite
        fileApi.uncompress(username, "$HOME/archives/confidential.zip",
            "$HOME/restored/confidential/", true, "SecurePass123");

        // Get available file classification levels
        List<Confidential> classifications = fileApi.getConfList(username);
        System.out.println("\nAvailable classification levels:");
        for (Confidential conf : classifications) {
            System.out.println("  ID: " + conf.getId() + " - Name: " + conf.getName());
        }

        // Mark file with security classification level
        fileApi.markConf(username, "999999998", "$HOME/projects/sensitive_data.csv");
        System.out.println("File marked with classification level 999999998");

        // List files with security classification info
        List<FileInfo> classifiedFiles = fileApi.getFileList(username, "$HOME/projects");
        for (FileInfo file : classifiedFiles) {
            if (file.getConfidential() != null) {
                System.out.println(file.getFileName() + " - Classification: " +
                    file.getConfidential());
            }
        }
    }
}
```

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

### Add Jhinno OpenAPI SDK Spring Boot Starter Dependency (XML)

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

This XML snippet shows how to add the Jhinno OpenAPI SDK Spring Boot Starter to your Maven project. Including this dependency in your pom.xml enables auto-configuration and seamless integration of the SDK within a Spring Boot application.

```xml
<!-- pom.xml - Add Spring Boot Starter dependency -->
<dependency>
    <groupId>com.jhinno</groupId>
    <artifactId>jhinno-openapi-sdk-spring-boot-starter</artifactId>
    <version>2.0.6</version>
</dependency>
```

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

### Java: Upload, Download, List, Copy, Rename, Delete Files

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

This Java code snippet demonstrates various file operations using the Jhinno OpenAPI SDK. It includes uploading files from local paths and InputStreams, listing files in a directory, generating download URLs, downloading files, copying files to new locations, renaming files, and deleting files. It requires the `com.jhinno.sdk.openapi.api.file.JHFileApiExecution` class and handles file streams for upload and download.

```java
import com.jhinno.sdk.openapi.api.file.JHFileApiExecution;
import com.jhinno.sdk.openapi.api.file.FileInfo;
import java.io.*;
import java.util.List;

public class FileOperationsExample {

    private JHFileApiExecution fileApi;

    public void demonstrateFileOperations() throws Exception {
        String username = "jhadmin";

        // Upload file from local filesystem with classification
        File localFile = new File("/path/to/local/document.pdf");
        FileInputStream fis = new FileInputStream(localFile);
        fileApi.uploadFile(username, fis, "document.pdf",
            "$HOME/uploads/", true, "secret"); // true=overwrite, secret=classification
        System.out.println("File uploaded to $HOME/uploads/document.pdf");

        // Upload file from InputStream (without classification)
        ByteArrayInputStream bais = new ByteArrayInputStream("Hello World".getBytes());
        fileApi.uploadFile(username, bais, "test.txt", "$HOME/");

        // List files in directory
        List<FileInfo> files = fileApi.getFileList(username, "$HOME/uploads");
        System.out.println("\nFiles in $HOME/uploads:");
        for (FileInfo file : files) {
            System.out.println("  " + file.getFileName());
            System.out.println("    Size: " + file.getSize() + " bytes");
            System.out.println("    Modified: " + file.getLastModified());
            System.out.println("    Owner: " + file.getOwner());
            System.out.println("    Permissions: " + file.getPermission());
            System.out.println("    Is folder: " + file.isFolder());
            System.out.println("    Readable: " + file.isRead());
            System.out.println("    Writable: " + file.isWrite());
        }

        // Get download URL for file
        String downloadUrl = fileApi.getFileDownloadUrl(username, "$HOME/uploads/document.pdf");
        System.out.println("\nDownload URL: " + downloadUrl);

        // Download file as InputStream
        InputStream fileStream = fileApi.getFileInputStream(username, "$HOME/uploads/document.pdf");
        FileOutputStream fos = new FileOutputStream("/path/to/local/downloaded.pdf");
        byte[] buffer = new byte[8192];
        int bytesRead;
        while ((bytesRead = fileStream.read(buffer)) != -1) {
            fos.write(buffer, 0, bytesRead);
        }
        fos.close();
        fileStream.close();
        System.out.println("File downloaded successfully");

        // Force download for classified files (requires permission)
        String classifiedUrl = fileApi.getFileDownloadUrl(username,
            "$HOME/classified/secret.doc", true);

        // Copy file to another location
        fileApi.copyFile(username, "$HOME/uploads/document.pdf",
            "$HOME/backup/");
        System.out.println("File copied to $HOME/backup/");

        // Rename file
        fileApi.renameFile(username, "$HOME/uploads/test.txt", "renamed.txt");

        // Delete file
        fileApi.deleteFile(username, "$HOME/uploads/renamed.txt");
        System.out.println("File deleted");
    }
}
```

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

### Submit and Monitor Batch Jobs with Java SDK

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

Demonstrates the complete workflow for submitting, monitoring, and managing batch jobs using the Jhinno OpenAPI Java SDK. This includes fetching submission forms, setting job parameters, submitting jobs, polling for status updates, retrieving output, and querying job lists. It requires the JHJobApiExecution class and related JobInfo objects.

```java
import com.jhinno.sdk.openapi.api.job.JHJobApiExecution;
import com.jhinno.sdk.openapi.api.job.JobInfo;
import com.jhinno.sdk.openapi.api.job.PageJobInfo;
import com.jhinno.sdk.openapi.api.job.JobActionEnum;
import com.jhinno.sdk.openapi.api.job.JobStatusEnum;
import com.jhinno.sdk.openapi.api.job.JobAppFormItemInfo;
import java.util.*;

public class BatchJobManagement {

    private JHJobApiExecution jobApi;

    public void demonstrateJobWorkflow() throws Exception {
        String username = "jhadmin";

        // Get job submission form for application
        List<JobAppFormItemInfo> formFields = jobApi.getSimulationAppForm(username, "common_sub");
        System.out.println("Job submission form fields:");
        for (JobAppFormItemInfo field : formFields) {
            System.out.println("  " + field.getName() + " (" + field.getType() +
                ") - Required: " + field.isRequired());
        }

        // Build job submission parameters
        Map<String, Object> jobParams = new HashMap<>();
        jobParams.put("JH_CAS", "$HOME/scripts/simulation.sh"); // Script to execute
        jobParams.put("JH_NCPU", "8"); // Number of CPUs
        jobParams.put("JH_MEM", "16384"); // Memory in MB
        jobParams.put("JH_QUEUE", "normal"); // Queue name
        jobParams.put("JH_JOB_CONF", "public"); // Security classification
        jobParams.put("JH_NAME", "CFD_Simulation_001"); // Job name
        jobParams.put("JH_CWD", "$HOME/projects/simulation"); // Working directory

        // Submit job
        String jobId = jobApi.submit(username, "common_sub", jobParams);
        System.out.println("\nJob submitted successfully!");
        System.out.println("Job ID: " + jobId);

        // Monitor job status with polling
        JobInfo job = null;
        boolean jobCompleted = false;
        while (!jobCompleted) {
            job = jobApi.getJobDetail(username, jobId);
            System.out.println("Job status: " + job.getStatus());
            System.out.println("Execution host: " + job.getExecutionHost());
            System.out.println("Submit time: " + job.getSubmitTime());

            if ("DONE".equals(job.getStatus()) || "EXIT".equals(job.getStatus())) {
                jobCompleted = true;
            } else if ("RUN".equals(job.getStatus())) {
                // Get dynamic output (peek at running job output)
                String output = jobApi.getJobPeek(username, jobId);
                System.out.println("Current output:\n" + output);
            }

            if (!jobCompleted) {
                Thread.sleep(5000); // Wait 5 seconds before checking again
            }
        }

        System.out.println("\nJob completed!");
        System.out.println("Execution time: " + job.getExecutionTime());
        System.out.println("Termination time: " + job.getTerminationTime());

        // Get job output files
        List<FileInfo> jobFiles = jobApi.getJobFilesById(username, jobId);
        System.out.println("\nJob output files:");
        for (FileInfo file : jobFiles) {
            System.out.println("  " + file.getFileName() + " (" + file.getSize() + " bytes)");
        }

        // Get detailed job history
        JobHistoryInfo history = jobApi.getJobHistory(username, jobId);
        System.out.println("\nJob history details available");

        // Query all running jobs
        PageJobInfo runningJobs = jobApi.getJobPage(username, 1, 20,
            null, JobStatusEnum.RUN, null);
        System.out.println("\nTotal running jobs: " + runningJobs.getTotalCount());
        System.out.println("Current page: " + runningJobs.getCurrentPage() +
            "/" + runningJobs.getTotalPage());

        for (JobInfo runningJob : runningJobs.getJobs()) {
            System.out.println("  Job " + runningJob.getJobId() + ": " + runningJob.getName());
        }

        // Get jobs by specific status
        List<JobInfo> pendingJobs = jobApi.getJobsByStatus(username, JobStatusEnum.PEND, 1, 10);
        System.out.println("\nPending jobs: " + pendingJobs.size());

        // Get jobs by name pattern
        List<JobInfo> cfdJobs = jobApi.getJobsByName(username, "CFD_", 1, 50);

        // Get multiple jobs by IDs
        List<String> jobIds = Arrays.asList("42", "43", "44");
        List<JobInfo> specificJobs = jobApi.getJobsByIds(username, jobIds);
    }

    public void demonstrateJobControl() throws Exception {
        String username = "jhadmin";
        String jobId = "42";

        // Suspend running job
        jobApi.action(username, JobActionEnum.STOP, jobId);
        System.out.println("Job suspended");

        // Resume suspended job
        jobApi.action(username, JobActionEnum.RESUME, jobId);
        System.out.println("Job resumed");

        // Move job to top of queue
        jobApi.action(username, JobActionEnum.TOP, jobId);

        // Move job to bottom of queue
        jobApi.action(username, JobActionEnum.BOT, jobId);
    }
}
```

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

### Manage Job Actions (Java)

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

Demonstrates how to perform actions on individual and multiple jobs using the JobApi. This includes killing single jobs, performing batch operations like killing or deleting multiple jobs, and connecting to interactive job sessions. It requires an authenticated user and job identifiers.

```java
import com.jhinno.sdk.openapi.api.JobApi;
import com.jhinno.sdk.openapi.api.enums.JobActionEnum;
import com.jhinno.sdk.openapi.api.enums.JobsActionEnum;
import java.util.Arrays;
import java.util.List;

public class JobManagement {

    private JobApi jobApi;

    public void demonstrateJobOperations(String username, String jobId) {
        // Kill job
        jobApi.action(username, JobActionEnum.KILL, jobId);
        System.out.println("Job killed");

        // Batch operations on multiple jobs
        List<String> jobIds = Arrays.asList("45", "46", "47");
        jobApi.actions(username, JobsActionEnum.KILL, jobIds);
        System.out.println("Multiple jobs killed");

        // Batch delete jobs from history
        jobApi.actions(username, JobsActionEnum.DELETE, jobIds);

        // Connect to interactive job session
        Object sessionInfo = jobApi.connectJobSession(username, jobId);
    }
}
```

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

### Demonstrate Usage of Custom API Execution in Java

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

This Java code shows how to use the `CustomApiExecution` class within a Spring service. It demonstrates calling custom API endpoints to retrieve user quota, submit a specialized job, and update resource allocations. This highlights the practical application of the custom SDK extension in an application context.

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.HashMap;

@Service
public class CustomApiService {

    @Autowired
    private CustomApiExecution customApi;

    public void demonstrateCustomApi() {
        String username = "jhadmin";

        // Use custom endpoint to get user quota
        UserQuotaDTO quota = customApi.getUserQuota(username);
        System.out.println("Disk usage: " + quota.getDiskUsed() + "/" + quota.getDiskQuota());
        System.out.println("Job count: " + quota.getCurrentJobs() + "/" + quota.getMaxJobs());

        // Submit custom job
        CustomJobRequest jobRequest = new CustomJobRequest();
        jobRequest.setJobType("ADVANCED_SIMULATION");
        jobRequest.setPriority(5);
        Map<String, Object> params = new HashMap<>();
        params.put("modelFile", "$HOME/models/advanced.sim");
        params.put("iterations", 10000);
        jobRequest.setParameters(params);

        CustomJobResult result = customApi.submitCustomJob(username, jobRequest);
        System.out.println("Custom job submitted: " + result.getJobId());

        // Update resource allocation
        ResourceUpdateDTO update = new ResourceUpdateDTO();
        update.setCpuLimit(16);
        update.setMemoryLimit(32768); // 32GB
        update.setStorageQuota(1073741824); // 1TB

        // Note: The original text was truncated here. Assuming it would continue to call updateResourceAllocation and potentially other methods.
    }
}

```

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

### Manage Users using Java SDK

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

Demonstrates user management operations using the JHUserApiExecution class, including searching users with filters, creating new users, updating existing user information, and resetting user passwords. This functionality requires the 'user_manager' permission. User creation involves setting various attributes like name, password, department, and contact information.

```java
import com.jhinno.sdk.openapi.api.organization.JHUserApiExecution;
import com.jhinno.sdk.openapi.api.organization.UserInfo;
import com.jhinno.sdk.openapi.api.organization.AddUpdateUserInfo;
import com.jhinno.sdk.openapi.api.organization.UpdateUserPasswordType;
import com.jhinno.sdk.openapi.api.PageResult;
import java.util.*;

public class OrganizationManagement {

    private JHUserApiExecution userApi;

    // Note: Requires 'user_manager' permission

    public void demonstrateUserOperations() throws Exception {
        String adminUsername = "jhadmin";

        // Search users with filters
        PageResult<UserInfo> users = userApi.getUserList(adminUsername,
            "john", "Engineering", null);
        System.out.println("Found users: " + users.getTotalCount());
        System.out.println("Page " + users.getCurrentPage() + " of " + users.getTotalPage());

        for (UserInfo user : users.getList()) {
            System.out.println("\nUser: " + user.getUserName());
            System.out.println("  Full name: " + user.getUserNameCn());
            System.out.println("  Department: " + user.getUserDepName());
            System.out.println("  Level: " + user.getUserLevel());
            System.out.println("  Email: " + user.getUserMail());
            System.out.println("  Phone: " + user.getUserTel());
            System.out.println("  Status: " + user.getUserStat());
            System.out.println("  Type: " + user.getUserType());
            System.out.println("  Max jobs: " + user.getUserMaxJobs());
            System.out.println("  Last login: " + user.getUserLoginTime());
            System.out.println("  Classification: " + user.getUserConf());
        }

        // Create new user
        AddUpdateUserInfo newUser = new AddUpdateUserInfo();
        newUser.setUserName("jsmith");
        newUser.setUserNameCn("John Smith");
        newUser.setUserPassword("SecurePassword123!");
        newUser.setUserCard("ID12345678"); // Employee ID or card number
        newUser.setDepName("Engineering");
        newUser.setUserMail("jsmith@company.com");
        newUser.setUserTel("123-456-7890");
        newUser.setUserNote("Senior software engineer");
        newUser.setUserConf("public"); // Security clearance level
        newUser.setUserRole("developer"); // Custom role

        // Set account expiration (optional)
        Calendar expiration = Calendar.getInstance();
        expiration.add(Calendar.YEAR, 1); // Expires in 1 year
        newUser.setUserExpireTime(expiration.getTime());

        userApi.addUser(adminUsername, newUser);
        System.out.println("\nUser 'jsmith' created successfully");

        // Update existing user
        AddUpdateUserInfo updateUser = new AddUpdateUserInfo();
        updateUser.setUserName("jsmith");
        updateUser.setUserTel("098-765-4321"); // Update phone
        updateUser.setUserMail("john.smith@company.com"); // Update email
        updateUser.setUserNote("Promoted to Lead Engineer");
        userApi.updateUser(adminUsername, updateUser);
        System.out.println("User 'jsmith' updated");

        // Reset user password (admin reset)
        userApi.updateUserPassword(adminUsername, "jsmith",
            null, "NewSecurePass456!",
            UpdateUserPasswordType.RESET_UPDATE_PASSWORD_TYPE);
        System.out.println("Password reset for 'jsmith'");

        // Force password change (user must change on next login)
        userApi.updateUserPassword(adminUsername, "jsmith",
            null, "TempPassword789",
            UpdateUserPasswordType.FORCE_UPDATE_PASSWORD_TYPE);
    }
}
```

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

### Manage Departments using Java SDK

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

Demonstrates how to perform CRUD operations on departments using the JHDepartmentApiExecution class. This requires the 'user_manager' permission. It includes fetching all departments, creating a new department, updating its details, and deleting a department.

```java
import com.jhinno.sdk.openapi.api.organization.JHDepartmentApiExecution;
import com.jhinno.sdk.openapi.api.organization.AddUpdateDepartment;
import java.util.*;

public class OrganizationManagement {

    private JHDepartmentApiExecution deptApi;

    // Note: Requires 'user_manager' permission

    public void demonstrateDepartmentOperations() throws Exception {
        String adminUsername = "jhadmin";

        // Get all departments
        List<Map<String, Object>> departments = deptApi.getDepartmentList(adminUsername);
        System.out.println("Departments:");
        for (Map<String, Object> dept : departments) {
            System.out.println("  " + dept.get("name") + " - ID: " + dept.get("id"));
        }

        // Create new department
        AddUpdateDepartment newDept = new AddUpdateDepartment();
        newDept.setDepName("Research and Development");
        newDept.setDepNote("R&D department for product innovation");
        deptApi.addDepartment(adminUsername, newDept);
        System.out.println("\nDepartment 'Research and Development' created");

        // Update department
        newDept.setDepNote("Updated: Advanced R&D for AI and HPC");
        deptApi.updateDepartment(adminUsername, newDept);
        System.out.println("Department updated");

        // Delete department
        deptApi.deleteDepartment(adminUsername, "Old Department");
        System.out.println("Department deleted");
    }
}
```

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

### Handle Various Exceptions in Java

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

This Java code snippet demonstrates how to catch and handle different exceptions that may arise from Jhinno SDK operations. It covers ArgsException for invalid inputs, ServiceException for server-side errors (including specific HTTP status codes), ClientException for client-side issues (like network problems or timeouts), and a general Exception catch for unexpected errors. Proper error handling ensures robust application behavior.

```java
import com.jhinno.sdk.openapi.ArgsException;
import com.jhinno.sdk.openapi.ClientException;
import com.jhinno.sdk.openapi.ServiceException;
import com.jhinno.sdk.openapi.ClientErrorCode;
import com.jhinno.sdk.openapi.api.file.JHFileApiExecution;
import com.jhinno.sdk.openapi.api.file.FileInfo;
import java.util.List;

public class ErrorHandlingExample {

    private JHFileApiExecution fileApi;

    public void demonstrateErrorHandling() {
        String username = "jhadmin";

        try {
            // Attempt to list files in a directory
            List<FileInfo> files = fileApi.getFileList(username, "$HOME/nonexistent");
            System.out.println("Files retrieved: " + files.size());

        } catch (ArgsException e) {
            // Invalid arguments passed to SDK method
            System.err.println("Invalid arguments: " + e.getMessage());
            System.err.println("Please check method parameters");

        } catch (ServiceException e) {
            // Server-side error (HTTP 4xx, 5xx)
            System.err.println("Server error occurred:");
            System.err.println("  Error code: " + e.getCode());
            System.err.println("  Message: " + e.getMessage());
            System.err.println("  Result: " + e.getResult());

            // Handle specific error codes
            if (e.getCode() == 404) {
                System.err.println("  Resource not found - directory may not exist");
            } else if (e.getCode() == 403) {
                System.err.println("  Access denied - check user permissions");
            } else if (e.getCode() == 401) {
                System.err.println("  Authentication failed - verify credentials");
            } else if (e.getCode() >= 500) {
                System.err.println("  Server error - retry later or contact admin");
            }

        } catch (ClientException e) {
            // Client-side error (network, timeout, connection issues)
            System.err.println("Client error occurred:");
            System.err.println("  Error code: " + e.getErrorCode());
            System.err.println("  Message: " + e.getMessage());

            // Handle specific client errors
            ClientErrorCode errorCode = e.getErrorCode();
            if (errorCode == ClientErrorCode.CONNECTION_TIMEOUT) {
                System.err.println("  Connection timeout - check network or increase timeout");
            } else if (errorCode == ClientErrorCode.NETWORK_ERROR) {
                System.err.println("  Network error - verify server URL and connectivity");
            } else if (errorCode == ClientErrorCode.SSL_ERROR) {
                System.err.println("  SSL error - check certificate configuration");
            } else if (errorCode == ClientErrorCode.TOKEN_EXPIRED) {
                System.err.println("  Token expired - SDK will automatically refresh");
            }

        } catch (Exception e) {
            // Unexpected errors
            System.err.println("Unexpected error: " + e.getClass().getName());
            System.err.println("Message: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public void demonstrateRetryLogic() {
        String username = "jhadmin";
        int maxRetries = 3;
        int retryDelayMs = 2000;

        for (int attempt = 1; attempt <= maxRetries; attempt++) {
            try {
                List<FileInfo> files = fileApi.getFileList(username, "$HOME");
                System.out.println("Success on attempt " + attempt);
                break; // Success - exit retry loop

            } catch (ServiceException e) {
                if (e.getCode() >= 500 && attempt < maxRetries) {
                    System.err.println("Server error on attempt " + attempt +
                        ", retrying in " + retryDelayMs + "ms...");
                    try {
                        Thread.sleep(retryDelayMs);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                } else {
                    System.err.println("Failed after " + attempt + " attempts");
                    throw e; // Rethrow if max retries reached or non-retryable error
                }

            } catch (ClientException e) {
                if (e.getErrorCode() == ClientErrorCode.CONNECTION_TIMEOUT
                    && attempt < maxRetries) {
                    System.err.println("Timeout on attempt " + attempt + ", retrying...");
                    try {
                        Thread.sleep(retryDelayMs);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                } else {
                    System.err.println("Client error - not retrying");
                    throw e;
                }
            }
        }
    }
}
```

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

### Use Injected API Executors in MyService (Java)

Source: https://context7.com/yanlongqi/jhinno-openapi-java-sdk/llms.txt

This Java service class, MyService, demonstrates how to use the injected Jhinno OpenAPI API executors. It shows how to fetch file lists for the current user and for a specific administrator user, utilizing the context provided by ApiConfig.

```java
// MyService.java - Use injected API executors
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import com.jhinno.sdk.openapi.api.file.JHFileApiExecution;
import com.jhinno.sdk.openapi.api.file.FileInfo;
import java.util.List;
import java.util.Map;

@Service
public class FileService {

    @Autowired
    private JHFileApiExecution fileApi;

    public List<FileInfo> getUserHomeFiles() {
        // No need to pass username - uses JHApiRequestHandler.getCurrentUserName()
        return fileApi.getFileList("$HOME");
    }

    public List<FileInfo> getAdminFiles() {
        // Override with explicit username
        return fileApi.getFileList("jhadmin", "$HOME");
    }
}
```
Tokens:
Raw