### Delete and Restore a Project

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Perform soft delete (moves to trash, can be restored) or hard delete (permanent). Includes an example of restoring a soft-deleted project.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;

public class DeleteProjectExample {
    public static void deleteProject(ProjectManagerClient client, String projectId) {
        // Soft delete (can be restored later)
        Boolean hardDelete = false;
        AstroResult<Object> deleteResult = client.getProjectClient()
            .deleteProject(projectId, hardDelete);

        if (deleteResult.getSuccess()) {
            System.out.println("Project moved to trash");

            // Restore the soft-deleted project
            AstroResult<Object> restoreResult = client.getProjectClient()
                .restoreProject(projectId);

            if (restoreResult.getSuccess()) {
                System.out.println("Project restored successfully");
            }
        } else {
            System.err.println("Delete failed: " + deleteResult.getError().getMessage());
        }
    }

    public static void hardDeleteProject(ProjectManagerClient client, String projectId) {
        // Permanent delete - cannot be restored
        Boolean hardDelete = true;
        AstroResult<Object> result = client.getProjectClient()
            .deleteProject(projectId, hardDelete);

        if (result.getSuccess()) {
            System.out.println("Project permanently deleted");
        }
    }
}
```

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

### Manage Task Assignees with Java SDK

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Demonstrates how to get, create, update, and delete task assignees using the Project Manager Java SDK. Ensure the ProjectManagerClient is properly initialized.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.ChangeSetStatusDto;
import com.projectmanager.models.AssigneeUpsertDto;
import com.projectmanager.models.AssigneeDto;
import com.projectmanager.models.IdDto;

public class TaskAssigneeExample {
    public static void manageAssignees(ProjectManagerClient client, String taskId) {
        // Get current assignees
        AstroResult<AssigneeDto[]> currentAssignees = client.getTaskAssigneeClient()
            .returnstaskassignees(taskId);

        if (currentAssignees.getSuccess()) {
            for (AssigneeDto assignee : currentAssignees.getData()) {
                System.out.println("Assigned: " + assignee.getId());
            }
        }

        // Create or update assignees with effort allocation
        AssigneeUpsertDto assignee1 = new AssigneeUpsertDto();
        assignee1.setId("resource-uuid-1");
        assignee1.setAssignedEffort(1200);  // 20 hours in minutes

        AssigneeUpsertDto assignee2 = new AssigneeUpsertDto();
        assignee2.setId("resource-uuid-2");
        assignee2.setAssignedEffort(600);   // 10 hours in minutes

        AssigneeUpsertDto[] assignees = {assignee1, assignee2};

        AstroResult<ChangeSetStatusDto> upsertResult = client.getTaskAssigneeClient()
            .createOrUpdateTaskAssignee(taskId, assignees);

        if (upsertResult.getSuccess()) {
            System.out.println("Assignees updated successfully");
        }

        // Remove specific assignees
        IdDto removeId = new IdDto();
        removeId.setId("resource-uuid-2");
        IdDto[] toRemove = {removeId};

        AstroResult<ChangeSetStatusDto> removeResult = client.getTaskAssigneeClient()
            .deleteTaskAssignees(taskId, toRemove);
    }
}

```

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

### Query Time Entries

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Retrieve time entries based on specified filters and ordering. This example queries entries within a date range and sorts them by date in descending order.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.TimesheetDto;

public class TimesheetExample {
    public static void queryTimeEntries(ProjectManagerClient client) {
        String filter = "date ge 2024-10-01 and date le 2024-10-31";
        String orderby = "date desc";

        AstroResult<TimesheetDto[]> result = client.getTimesheetClient()
            .queryTimeEntries(100, 0, filter, orderby, null);

        if (result.getSuccess()) {
            TimesheetDto[] entries = result.getData();
            int totalMinutes = 0;
            for (TimesheetDto entry : entries) {
                totalMinutes += entry.getMinutes();
            }
            System.out.println("Total hours logged: " + (totalMinutes / 60.0));
        }
    }
}
```

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

### Create Multiple Tasks in Bulk in Java

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Groups multiple TaskCreateDto objects into an array to perform a single API call for efficient project structure setup.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.ChangeSetStatusDto;
import com.projectmanager.models.TaskCreateDto;

public class BulkCreateTasksExample {
    public static void createMultipleTasks(ProjectManagerClient client, String projectId) {
        TaskCreateDto task1 = new TaskCreateDto();
        task1.setName("Phase 1: Research");
        task1.setPlannedStartDate("2024-10-01");
        task1.setPlannedFinishDate("2024-10-07");
        task1.setIndex(1);

        TaskCreateDto task2 = new TaskCreateDto();
        task2.setName("Phase 2: Development");
        task2.setPlannedStartDate("2024-10-08");
        task2.setPlannedFinishDate("2024-10-21");
        task2.setIndex(2);

        TaskCreateDto task3 = new TaskCreateDto();
        task3.setName("Phase 3: Testing");
        task3.setPlannedStartDate("2024-10-22");
        task3.setPlannedFinishDate("2024-10-28");
        task3.setIndex(3);

        TaskCreateDto[] tasks = {task1, task2, task3};

        AstroResult<ChangeSetStatusDto[]> result = client.getTaskClient()
            .createManyTasks(projectId, tasks);

        if (result.getSuccess()) {
            ChangeSetStatusDto[] statuses = result.getData();
            System.out.println("Created " + statuses.length + " tasks successfully");
        } else {
            System.err.println("Bulk creation failed: " + result.getError().getMessage());
        }
    }
}
```

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

### Create Resource with Java SDK

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Shows how to create a new resource, including setting basic details and hourly rate. The `ProjectManagerClient` must be initialized.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.ResourceDto;
import com.projectmanager.models.ResourceCreateDto;
import com.projectmanager.models.ResourceUpdateDto;

public class ResourceManagementExample {
    public static void createResource(ProjectManagerClient client) {
        ResourceCreateDto newResource = new ResourceCreateDto();
        newResource.setFirstName("John");
        newResource.setLastName("Smith");
        newResource.setEmail("john.smith@company.com");
        newResource.setHourlyRate(85.00);

        AstroResult<ResourceDto> result = client.getResourceClient()
            .createResource(newResource);

        if (result.getSuccess()) {
            ResourceDto resource = result.getData();
            System.out.println("Resource created: " + resource.getId());

            // Resend invitation email if needed
            client.getResourceClient().resendInviteEmail(resource.getId());
        }
    }

    public static void queryResources(ProjectManagerClient client) {
        // Query all active resources
        String filter = "isActive eq true";
        String orderby = "lastName asc";

        AstroResult<ResourceDto[]> result = client.getResourceClient()
            .queryResources(50, 0, filter, orderby, null);

        if (result.getSuccess()) {
            ResourceDto[] resources = result.getData();
            for (ResourceDto resource : resources) {
                System.out.println("Resource: " + resource.getFirstName() +
                    " " + resource.getLastName());
            }
        }
    }

    public static void updateResource(ProjectManagerClient client, String resourceId) {
        ResourceUpdateDto update = new ResourceUpdateDto();
        update.setHourlyRate(95.00);

        AstroResult<ResourceDto> result = client.getResourceClient()
            .updateResource(resourceId, update);

        if (result.getSuccess()) {
            System.out.println("Resource hourly rate updated");
        }
    }
}

```

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

### Initialize ProjectManagerClient

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Configure the client using either the production environment or a custom proxy URL with an API key.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;

public class ProjectManagerSetup {
    public static ProjectManagerClient createClient() {
        // Initialize the client with production environment and API key
        ProjectManagerClient client = ProjectManagerClient
            .withEnvironment("https://api.projectmanager.com")
            .withBearerToken("your-api-key-here")
            .withApplicationName("MyJavaApplication");

        return client;
    }

    // For custom or proxy environments
    public static ProjectManagerClient createCustomClient() {
        return ProjectManagerClient
            .withCustomEnvironment("https://your-proxy-server.com")
            .withBearerToken("your-api-key-here")
            .withApplicationName("MyJavaApplication");
    }
}
```

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

### Download and Manage Files with Java SDK

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Demonstrates downloading files as binary or HTML-processed text, downloading thumbnails, and performing soft or hard deletes of files. Ensure the ProjectManagerClient is properly initialized.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.UpdateRequestDto;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileManagementExample {
    public static void downloadFile(ProjectManagerClient client, String documentId) {
        // Download file as binary
        AstroResult<byte[]> result = client.getFileClient()
            .downloadFile(documentId, null);

        if (result.getSuccess()) {
            byte[] fileContent = result.getData();

            try (FileOutputStream fos = new FileOutputStream("downloaded_file.pdf")) {
                fos.write(fileContent);
                System.out.println("File downloaded: " + fileContent.length + " bytes");
            } catch (IOException e) {
                System.err.println("Error saving file: " + e.getMessage());
            }
        }

        // Download as HTML-processed text
        AstroResult<byte[]> htmlResult = client.getFileClient()
            .downloadFile(documentId, "html");
    }

    public static void downloadThumbnail(ProjectManagerClient client, String documentId) {
        AstroResult<byte[]> result = client.getFileClient()
            .downloadaThumbnailImage(documentId);

        if (result.getSuccess()) {
            byte[] thumbnail = result.getData();
            System.out.println("Thumbnail size: " + thumbnail.length + " bytes");
        }
    }

    public static void deleteFile(ProjectManagerClient client, String fileId) {
        // Soft delete (moves to trash)
        AstroResult<Object> softDelete = client.getFileClient()
            .deletefile(fileId, false);

        // Hard delete (permanent)
        AstroResult<Object> hardDelete = client.getFileClient()
            .deletefile(fileId, true);
    }
}
```

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

### Create a New Project

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Define project parameters using a ProjectCreateDto and submit the request via the ProjectClient.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.ProjectDto;
import com.projectmanager.models.ProjectCreateDto;

public class CreateProjectExample {
    public static void createProject(ProjectManagerClient client) {
        ProjectCreateDto newProject = new ProjectCreateDto();
        newProject.setName("Q4 Marketing Campaign");
        newProject.setDescription("Launch marketing campaign for Q4 product release");
        newProject.setBudget(50000.00);
        newProject.setTargetDate("2024-12-31");
        newProject.setFavorite(true);
        newProject.setHourlyRate(75.00);

        AstroResult<ProjectDto> result = client.getProjectClient().createProject(newProject);

        if (result.getSuccess()) {
            ProjectDto project = result.getData();
            System.out.println("Project created successfully");
            System.out.println("Project ID: " + project.getId());
            System.out.println("Short ID: " + project.getShortId());
        } else {
            System.err.println("Failed to create project: " + result.getError().getMessage());
        }
    }
}
```

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

### Create ProjectManager API Client in Java

Source: https://github.com/projectmgr/projectmanager-sdk-java/blob/main/README.md

Use this method to create an API client for ProjectManager within Java. You must specify your API key and your environment URL. The 'WithAppName' parameter is optional but recommended.

```java
import com.projectmanager.ProjectManagerClient;

public class JavaExample
{
    public static ProjectManagerClient GetProjectManagerClient(String apiKey, String env)
    {
        return ProjectManagerClient
            .withEnvironment(env)
            .withBearerToken(apiKey)
            .WithAppName("MyApplicationName");
    }
}
```

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

### Manage Integrations with Java SDK

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Shows how to retrieve all integrations, enable a specific integration, and disable an integration using the Project Manager SDK. Requires a valid integration ID.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.IntegrationDto;

public class IntegrationExample {
    public static void manageIntegrations(ProjectManagerClient client) {
        // Get all available integrations
        AstroResult<IntegrationDto[]> allIntegrations = client.getIntegrationClient()
            .retrieveAllIntegrations();

        if (allIntegrations.getSuccess()) {
            for (IntegrationDto integration : allIntegrations.getData()) {
                System.out.println("Integration: " + integration.getName() +
                    " - Enabled: " + integration.getEnabled());
            }
        }

        // Enable a specific integration
        String integrationId = "integration-uuid";
        AstroResult<IntegrationDto> enableResult = client.getIntegrationClient()
            .enableIntegration(integrationId);

        if (enableResult.getSuccess()) {
            System.out.println("Integration enabled");
        }

        // Disable an integration
        AstroResult<Object> disableResult = client.getIntegrationClient()
            .disableIntegration(integrationId);
    }
}
```

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

### Retrieve and Update a Project

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Fetch an existing project by its unique identifier and update its properties. Requires retrieving the project first, then applying updates using a ProjectUpdateDto.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.ProjectDto;
import com.projectmanager.models.ProjectUpdateDto;

public class UpdateProjectExample {
    public static void updateProject(ProjectManagerClient client, String projectId) {
        // First retrieve the project
        AstroResult<ProjectDto> getResult = client.getProjectClient().retrieveProject(projectId);

        if (!getResult.getSuccess()) {
            System.err.println("Project not found: " + getResult.getError().getMessage());
            return;
        }

        // Update the project properties
        ProjectUpdateDto update = new ProjectUpdateDto();
        update.setDescription("Updated project description with new scope");
        update.setBudget(75000.00);
        update.setStatusUpdate("Project on track for Q4 delivery");

        AstroResult<Object> updateResult = client.getProjectClient()
            .updateProject(projectId, update);

        if (updateResult.getSuccess()) {
            System.out.println("Project updated successfully");
        } else {
            System.err.println("Update failed: " + updateResult.getError().getMessage());
        }
    }
}
```

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

### Manage Project Risks in Java

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Use this to create, retrieve, query, and update project risks. Requires importing specific DTOs and the ProjectManagerClient.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.RiskDto;
import com.projectmanager.models.RiskDetailsDto;
import com.projectmanager.models.RiskCreateDto;
import com.projectmanager.models.RiskUpdateDto;

public class RiskManagementExample {
    public static void manageRisks(ProjectManagerClient client, String projectId) {
        // Create a new risk
        RiskCreateDto newRisk = new RiskCreateDto();
        newRisk.setName("Resource availability risk");
        newRisk.setDescription("Key team member may be unavailable during critical phase");
        newRisk.setProbability(0.6);  // 60% likelihood
        newRisk.setImpact(0.8);       // High impact

        AstroResult<RiskDto> createResult = client.getRiskClient()
            .createRisk(projectId, newRisk);

        if (createResult.getSuccess()) {
            RiskDto risk = createResult.getData();
            System.out.println("Risk created: " + risk.getId());
        }

        // Get all risks for a project
        AstroResult<RiskDetailsDto[]> risksResult = client.getRiskClient()
            .getRisksforProject(projectId);

        if (risksResult.getSuccess()) {
            RiskDetailsDto[] risks = risksResult.getData();
            System.out.println("Project has " + risks.length + " risks");
        }

        // Query risks with OData
        String filter = "probability gt 0.5";
        AstroResult<RiskDto[]> queryResult = client.getRiskClient()
            .queryRisks(20, 0, filter, "impact desc", null);
    }

    public static void updateRisk(ProjectManagerClient client, String riskId) {
        RiskUpdateDto update = new RiskUpdateDto();
        update.setStatus("Mitigated");
        update.setResolution("Hired backup contractor");

        AstroResult<RiskDto> result = client.getRiskClient().updateRisk(riskId, update);

        if (result.getSuccess()) {
            System.out.println("Risk updated");
        }
    }
}
```

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

### Create a Time Entry

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Use this to create a new time entry for a specific task and resource. Ensure all required fields like taskId, resourceId, date, and minutes are provided.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.TimesheetResponseDto;
import com.projectmanager.models.TimesheetCreateRequestDto;

public class TimesheetExample {
    public static void createTimeEntry(ProjectManagerClient client) {
        TimesheetCreateRequestDto timeEntry = new TimesheetCreateRequestDto();
        timeEntry.setTaskId("task-uuid");
        timeEntry.setResourceId("resource-uuid");
        timeEntry.setDate("2024-10-15");
        timeEntry.setMinutes(480);  // 8 hours in minutes
        timeEntry.setNotes("Completed landing page design");

        AstroResult<TimesheetResponseDto> result = client.getTimesheetClient()
            .createTimeEntry(timeEntry);

        if (result.getSuccess()) {
            System.out.println("Time entry created: " + result.getData().getId());
        }
    }
}
```

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

### Query Tasks with OData Filtering in Java

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Query tasks using OData filters and sorting. Ensure the ProjectManagerClient is properly initialized before use.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.TaskDto;
import com.projectmanager.models.TaskDetailsDto;
import com.projectmanager.models.TaskUpdateDto;
import com.projectmanager.models.ChangeSetStatusDto;

public class QueryUpdateTasksExample {
    public static void queryTasks(ProjectManagerClient client) {
        // Query tasks with filtering
        String filter = "percentComplete lt 100";  // Incomplete tasks
        String orderby = "plannedFinishDate asc";  // Sort by due date

        AstroResult<TaskDto[]> result = client.getTaskClient()
            .queryTasks(20, 0, filter, orderby, null);

        if (result.getSuccess()) {
            TaskDto[] tasks = result.getData();
            for (TaskDto task : tasks) {
                System.out.println("Task: " + task.getName() +
                    " - " + task.getPercentComplete() + "% complete");
            }
        }
    }

    public static void updateTaskProgress(ProjectManagerClient client, String taskId) {
        // Retrieve task details first
        AstroResult<TaskDetailsDto> getResult = client.getTaskClient().retrieveTask(taskId);

        if (getResult.getSuccess()) {
            // Update task progress
            TaskUpdateDto update = new TaskUpdateDto();
            update.setPercentComplete(75);
            update.setActualStartDate("2024-10-01");

            AstroResult<ChangeSetStatusDto> updateResult = client.getTaskClient()
                .updateTask(taskId, update);

            if (updateResult.getSuccess()) {
                System.out.println("Task progress updated to 75%");
            }
        }
    }
}
```

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

### Query Projects with OData Filtering

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Retrieve a filtered list of projects using OData query syntax for advanced filtering, sorting, and pagination. Specify parameters like top, skip, filter, orderby, and expand.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.ProjectDto;

public class QueryProjectsExample {
    public static void queryProjects(ProjectManagerClient client) {
        // Query with pagination, filtering, and sorting
        Integer top = 10;        // Return 10 records
        Integer skip = 0;        // Start from first record
        String filter = "isDeleted eq false";  // Only active projects
        String orderby = "name asc";           // Sort by name
        String expand = null;                   // Include related data

        AstroResult<ProjectDto[]> result = client.getProjectClient()
            .queryProjects(top, skip, filter, orderby, expand);

        if (result.getSuccess()) {
            ProjectDto[] projects = result.getData();
            System.out.println("Found " + projects.length + " projects");

            for (ProjectDto project : projects) {
                System.out.println("- " + project.getName() + " (" + project.getShortId() + ")");
            }
        } else {
            System.err.println("Query failed: " + result.getError().getMessage());
        }
    }
}
```

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

### Manage Task Hierarchy in Java

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Manage parent-child task relationships, including adding, updating, and removing parent tasks. Ensure valid task IDs are provided.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.ChangeSetStatusDto;
import com.projectmanager.models.TaskDto;

public class TaskHierarchyExample {
    public static void manageTaskHierarchy(ProjectManagerClient client,
                                            String childTaskId,
                                            String parentTaskId) {
        // Add parent relationship to make this a subtask
        AstroResult<ChangeSetStatusDto> addResult = client.getTaskClient()
            .addParentTask(childTaskId, parentTaskId);

        if (addResult.getSuccess()) {
            System.out.println("Task added as subtask");
        }

        // Get all first-level subtasks of a parent task
        AstroResult<TaskDto[]> subtasksResult = client.getTaskClient()
            .fetchthefirstlevelchildtasksfromthetask(parentTaskId);

        if (subtasksResult.getSuccess()) {
            TaskDto[] subtasks = subtasksResult.getData();
            System.out.println("Found " + subtasks.length + " subtasks");
        }

        // Update parent to a different task
        String newParentId = "new-parent-task-uuid";
        AstroResult<ChangeSetStatusDto> updateResult = client.getTaskClient()
            .updateParentTask(childTaskId, newParentId);

        // Remove parent relationship (make task top-level)
        AstroResult<ChangeSetStatusDto> removeResult = client.getTaskClient()
            .removeParentTask(childTaskId);
    }
}
```

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

### Add ProjectManager SDK to Maven Project

Source: https://github.com/projectmgr/projectmanager-sdk-java/blob/main/README.md

Add this dependency to your pom.xml file to include the ProjectManager SDK. Check the SonaType central page for the latest version number.

```xml
<dependency>
    <groupId>com.projectmanager</groupId>
    <artifactId>projectmanagersdk</artifactId>
    <version>97.0.2178</version>
</dependency>
```

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

### Create a Single Task in Java

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Uses TaskCreateDto to define task properties and assigns resources via UUIDs before submitting to the client.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.ChangeSetStatusDto;
import com.projectmanager.models.TaskCreateDto;

public class CreateTaskExample {
    public static void createTask(ProjectManagerClient client, String projectId) {
        TaskCreateDto newTask = new TaskCreateDto();
        newTask.setName("Design Landing Page Mockups");
        newTask.setDescription("Create initial mockups for the campaign landing page");
        newTask.setPlannedStartDate("2024-10-01");
        newTask.setPlannedFinishDate("2024-10-15");
        newTask.setPlannedDuration(10080);  // Duration in minutes (7 days)
        newTask.setPlannedEffort(2400);     // Effort in minutes (40 hours)
        newTask.setPercentComplete(0);
        newTask.setPriorityId(1);           // High priority
        newTask.setTheme("Blue");
        newTask.setIsMilestone(false);

        // Assign resources to the task (by resource IDs)
        String[] assignees = {"resource-uuid-1", "resource-uuid-2"};
        newTask.setAssignees(assignees);

        AstroResult<ChangeSetStatusDto> result = client.getTaskClient()
            .createTask(projectId, newTask);

        if (result.getSuccess()) {
            ChangeSetStatusDto status = result.getData();
            System.out.println("Task created successfully");
            System.out.println("Changeset ID: " + status.getChangeSetId());
        } else {
            System.err.println("Failed to create task: " + result.getError().getMessage());
        }
    }
}
```

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

### Approve Timesheet

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Submit a timesheet for approval and then approve it. This involves creating a TimeSheetApprovalDto with the resourceId and date of the timesheet to be approved.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.TimeSheetApprovalDto;
import com.projectmanager.models.TimeSheetApprovalResponseDto;

public class TimesheetExample {
    public static void approveTimesheet(ProjectManagerClient client) {
        TimeSheetApprovalDto approval = new TimeSheetApprovalDto();
        approval.setResourceId("resource-uuid");
        approval.setDate("2024-10-14");  // Monday of the week to approve

        // Submit for approval
        AstroResult<TimeSheetApprovalResponseDto> submitResult = client.getTimesheetClient()
            .submitTimeSheet(approval);

        // Approve the timesheet (manager action)
        AstroResult<TimeSheetApprovalResponseDto> approveResult = client.getTimesheetClient()
            .approveTimeSheet(approval);

        if (approveResult.getSuccess()) {
            System.out.println("Timesheet approved");
        }
    }
}
```

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

### Retrieve Current User Information

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Fetch details about the authenticated user using the Me client and handle the resulting AstroResult.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.WorkSpaceUserInfoDto;

public class UserInfoExample {
    public static void getCurrentUser(ProjectManagerClient client) {
        AstroResult<WorkSpaceUserInfoDto> result = client.getMeClient().retrieveMe();

        if (result.getSuccess()) {
            WorkSpaceUserInfoDto userInfo = result.getData();
            System.out.println("User authenticated successfully");
            System.out.println("Status Code: " + result.getStatusCode());
        } else {
            System.err.println("Authentication failed: " + result.getError().getMessage());
        }
    }
}
```

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

### Manage Task Comments and Discussions in Java

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Use this to add, retrieve, like, unlike, and delete comments on tasks. Requires importing specific DTOs and the ProjectManagerClient.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.DiscussionCommentDto;
import com.projectmanager.models.DiscussionCommentCreateDto;
import com.projectmanager.models.DiscussionCommentCreateResponseDto;

public class TaskDiscussionExample {
    public static void manageComments(ProjectManagerClient client, String taskId) {
        // Create a new comment with Markdown formatting
        DiscussionCommentCreateDto comment = new DiscussionCommentCreateDto();
        comment.setText("## Update\n\nCompleted the following:\n- Design mockups\n- Initial review\n\n**Next steps:** Development phase");

        AstroResult<DiscussionCommentCreateResponseDto> createResult = client.getDiscussionClient()
            .createTaskComment(taskId, comment);

        if (createResult.getSuccess()) {
            String commentId = createResult.getData().getId();
            System.out.println("Comment added: " + commentId);

            // Like the comment
            client.getDiscussionClient().likeComment(commentId);
        }

        // Retrieve all comments for a task
        AstroResult<DiscussionCommentDto[]> commentsResult = client.getDiscussionClient()
            .retrieveTaskComments(taskId);

        if (commentsResult.getSuccess()) {
            DiscussionCommentDto[] comments = commentsResult.getData();
            System.out.println("Task has " + comments.length + " comments");

            for (DiscussionCommentDto c : comments) {
                System.out.println("- " + c.getText());
            }
        }
    }

    public static void deleteComment(ProjectManagerClient client, String commentId) {
        // Unlike first if needed
        client.getDiscussionClient().unlikeComment(commentId);

        // Remove the comment
        AstroResult<Object> result = client.getDiscussionClient().removeComment(commentId);

        if (result.getSuccess()) {
            System.out.println("Comment removed");
        }
    }
}
```

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

### Manage Tags

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Perform CRUD operations on tags, including creating, updating, and querying. Tags can be used to categorize tasks and projects.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.models.TagDto;
import com.projectmanager.models.TagCreateDto;
import com.projectmanager.models.TagUpdateDto;

public class TagManagementExample {
    public static void manageTags(ProjectManagerClient client) {
        // Create a new tag
        TagCreateDto newTag = new TagCreateDto();
        newTag.setName("High Priority");
        newTag.setColor("#FF0000");

        AstroResult<TagDto> createResult = client.getTagClient().createTag(newTag);

        if (createResult.getSuccess()) {
            TagDto tag = createResult.getData();
            System.out.println("Tag created: " + tag.getId());

            // Update the tag
            TagUpdateDto update = new TagUpdateDto();
            update.setName("Critical Priority");
            update.setColor("#FF4444");

            AstroResult<TagDto> updateResult = client.getTagClient()
                .updateTag(tag.getId(), update);
        }

        // Query all tags
        AstroResult<TagDto[]> queryResult = client.getTagClient()
            .queryTags(100, 0, null, "name asc", null);

        if (queryResult.getSuccess()) {
            for (TagDto tag : queryResult.getData()) {
                System.out.println("Tag: " + tag.getName() + " (" + tag.getColor() + ")");
            }
        }
    }
}
```

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

### Handle API Errors with AstroResult in Java

Source: https://context7.com/projectmgr/projectmanager-sdk-java/llms.txt

Use the AstroResult wrapper to check for success or failure after an API call. Handle specific error status codes or a default unknown error.

```java
import com.projectmanager.ProjectManagerClient;
import com.projectmanager.AstroResult;
import com.projectmanager.AstroError;
import com.projectmanager.models.ProjectDto;

public class ErrorHandlingExample {
    public static void robustApiCall(ProjectManagerClient client, String projectId) {
        AstroResult<ProjectDto> result = client.getProjectClient().retrieveProject(projectId);

        // Check success status
        if (result.getSuccess()) {
            ProjectDto project = result.getData();
            System.out.println("Successfully retrieved: " + project.getName());
        } else {
            // Handle error
            AstroError error = result.getError();
            String statusCode = result.getStatusCode();

            switch (statusCode) {
                case "401":
                    System.err.println("Authentication failed - check your API key");
                    break;
                case "403":
                    System.err.println("Access denied - insufficient permissions");
                    break;
                case "404":
                    System.err.println("Project not found: " + projectId);
                    break;
                case "429":
                    System.err.println("Rate limited - please slow down requests");
                    break;
                default:
                    System.err.println("API Error (" + statusCode + "): " +
                        (error != null ? error.getMessage() : "Unknown error"));
            }
        }

        // Alternative: Check hasError flag
        if (result.getHasError()) {
            System.err.println("Request failed");
        }
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.