966 lines
31 KiB
TypeScript
966 lines
31 KiB
TypeScript
import axios from 'axios';
|
|
|
|
export class LeantimeService {
|
|
private apiUrl: string;
|
|
private apiToken: string;
|
|
private apiUserId: string | null;
|
|
|
|
constructor() {
|
|
this.apiUrl = process.env.LEANTIME_API_URL || '';
|
|
this.apiToken = process.env.LEANTIME_TOKEN || '';
|
|
this.apiUserId = null; // Will be fetched when needed
|
|
console.log('LeantimeService initialized with URL:', this.apiUrl);
|
|
}
|
|
|
|
/**
|
|
* Get the properly formatted API endpoint
|
|
* @returns The formatted API endpoint
|
|
*/
|
|
private getApiEndpoint(): string {
|
|
return this.apiUrl.endsWith('/api/jsonrpc')
|
|
? this.apiUrl
|
|
: this.apiUrl.endsWith('/')
|
|
? `${this.apiUrl}api/jsonrpc`
|
|
: `${this.apiUrl}/api/jsonrpc`;
|
|
}
|
|
|
|
/**
|
|
* Create a new project in Leantime
|
|
* @param mission The mission data
|
|
* @returns Project ID or throws error
|
|
*/
|
|
async createProject(mission: any): Promise<number> {
|
|
try {
|
|
// Determine client ID based on mission type
|
|
const clientId = mission.niveau.toLowerCase() === 'a' ?
|
|
await this.getClientIdByName('Enkun') :
|
|
await this.getClientIdByName('ONG');
|
|
|
|
if (!clientId) {
|
|
throw new Error(`Leantime client not found for mission type ${mission.niveau}`);
|
|
}
|
|
|
|
// Generate dates for the project (today and one year from now)
|
|
const today = new Date();
|
|
const endDate = new Date();
|
|
endDate.setFullYear(today.getFullYear() + 1);
|
|
|
|
const formattedStartDate = today.toISOString().split('T')[0];
|
|
const formattedEndDate = endDate.toISOString().split('T')[0];
|
|
|
|
console.log(`Creating project with dates: start=${formattedStartDate}, end=${formattedEndDate}`);
|
|
|
|
// Create project values object
|
|
const projectData = {
|
|
name: mission.name,
|
|
clientId: clientId,
|
|
details: mission.intention || '',
|
|
type: 'project',
|
|
start: formattedStartDate,
|
|
end: formattedEndDate,
|
|
status: 'open',
|
|
psettings: 'restricted'
|
|
};
|
|
|
|
console.log('Creating project with data:', JSON.stringify(projectData, null, 2));
|
|
|
|
// Create with direct call to createProject
|
|
const createResponse = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.createProject',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: projectData
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
// Log the response
|
|
console.log('Create response status:', createResponse.status);
|
|
console.log('Create response data:', JSON.stringify(createResponse.data, null, 2));
|
|
|
|
if (createResponse.data && createResponse.data.result) {
|
|
const projectId = createResponse.data.result;
|
|
console.log(`Created Leantime project with ID: ${projectId}`);
|
|
|
|
// If the mission has a logo, set it as project avatar
|
|
if (mission.logo) {
|
|
await this.setProjectAvatar(projectId, mission.logo);
|
|
}
|
|
|
|
// Assign users to the project
|
|
if (mission.missionUsers && mission.missionUsers.length > 0) {
|
|
await this.assignUsersToProject(projectId, mission.missionUsers);
|
|
}
|
|
|
|
return projectId;
|
|
}
|
|
|
|
// Fall back to addProject if createProject fails
|
|
console.log('createProject failed, trying addProject...');
|
|
|
|
// Based on the error message, Leantime expects a nested 'values' parameter
|
|
const payload = {
|
|
method: 'leantime.rpc.Projects.Projects.addProject',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
values: {
|
|
name: mission.name,
|
|
clientId: clientId,
|
|
details: mission.intention || '',
|
|
type: 'project',
|
|
start: formattedStartDate,
|
|
end: formattedEndDate,
|
|
status: 'open',
|
|
psettings: 'restricted'
|
|
}
|
|
}
|
|
};
|
|
|
|
console.log('addProject payload:', JSON.stringify(payload, null, 2));
|
|
|
|
const response = await axios.post(
|
|
this.getApiEndpoint(),
|
|
payload,
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
console.log('addProject response status:', response.status);
|
|
console.log('addProject response data:', JSON.stringify(response.data, null, 2));
|
|
|
|
if (!response.data || !response.data.result) {
|
|
throw new Error(`Failed to create Leantime project: ${JSON.stringify(response.data)}`);
|
|
}
|
|
|
|
const projectId = response.data.result;
|
|
console.log(`Created Leantime project with ID: ${projectId}`);
|
|
|
|
// If the mission has a logo, set it as project avatar
|
|
if (mission.logo) {
|
|
await this.setProjectAvatar(projectId, mission.logo);
|
|
}
|
|
|
|
// Assign users to the project
|
|
if (mission.missionUsers && mission.missionUsers.length > 0) {
|
|
await this.assignUsersToProject(projectId, mission.missionUsers);
|
|
}
|
|
|
|
return projectId;
|
|
} catch (error) {
|
|
if (axios.isAxiosError(error) && error.response) {
|
|
console.error('Axios Error Details:', {
|
|
status: error.response.status,
|
|
data: error.response.data,
|
|
headers: error.response.headers
|
|
});
|
|
}
|
|
console.error('Error creating Leantime project:', error);
|
|
throw new Error(`Leantime integration failed: ${error instanceof Error ? error.message : String(error)}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set project avatar using mission logo
|
|
* @param projectId The Leantime project ID
|
|
* @param logoPath The mission logo URL
|
|
*/
|
|
async setProjectAvatar(projectId: number, logoPath: string): Promise<void> {
|
|
try {
|
|
// Get the logo file from the storage
|
|
const logoResponse = await fetch(`/api/missions/image/${logoPath}`);
|
|
if (!logoResponse.ok) {
|
|
throw new Error(`Failed to fetch logo file: ${logoResponse.statusText}`);
|
|
}
|
|
|
|
const formData = new FormData();
|
|
const logoBlob = await logoResponse.blob();
|
|
|
|
// Add the file to form data
|
|
formData.append('file', logoBlob, 'logo.png');
|
|
formData.append('project', JSON.stringify({ id: projectId }));
|
|
|
|
// Get base URL by removing any API path
|
|
const baseUrl = this.apiUrl
|
|
.replace('/api/jsonrpc', '')
|
|
.replace('/api/jsonrpc.php', '');
|
|
|
|
// Construct proper avatar endpoint
|
|
const avatarEndpoint = baseUrl.endsWith('/')
|
|
? `${baseUrl}api/v1/projects.setProjectAvatar`
|
|
: `${baseUrl}/api/v1/projects.setProjectAvatar`;
|
|
|
|
console.log('Using avatar endpoint:', avatarEndpoint);
|
|
|
|
// Upload the avatar
|
|
const response = await axios.post(
|
|
avatarEndpoint,
|
|
formData,
|
|
{
|
|
headers: {
|
|
'Content-Type': 'multipart/form-data',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (!response.data || !response.data.success) {
|
|
throw new Error(`Failed to set project avatar: ${JSON.stringify(response.data)}`);
|
|
}
|
|
|
|
console.log(`Set avatar for Leantime project ${projectId}`);
|
|
} catch (error) {
|
|
console.error('Error setting project avatar:', error);
|
|
// Don't fail the entire process if avatar upload fails
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the API user's ID for use in project assignments
|
|
* This is useful when all other methods of user assignment fail
|
|
*/
|
|
private async getApiUserId(): Promise<string | null> {
|
|
if (this.apiUserId) {
|
|
return this.apiUserId;
|
|
}
|
|
|
|
try {
|
|
const response = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Auth.getCurrentUser',
|
|
jsonrpc: '2.0',
|
|
id: 1
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response.data && response.data.result && response.data.result.id) {
|
|
this.apiUserId = response.data.result.id;
|
|
console.log(`Found API user ID: ${this.apiUserId}`);
|
|
return this.apiUserId;
|
|
}
|
|
|
|
return null;
|
|
} catch (error) {
|
|
console.error('Error getting API user ID:', error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assign mission users to the Leantime project
|
|
* @param projectId The Leantime project ID
|
|
* @param missionUsers The mission users with roles
|
|
*/
|
|
async assignUsersToProject(projectId: number, missionUsers: any[]): Promise<void> {
|
|
console.log(`Attempting to add ${missionUsers.length} users to project ${projectId}`);
|
|
|
|
// Create a direct URL to the project that can be shared with users
|
|
const baseUrl = this.apiUrl
|
|
.replace('/api/jsonrpc', '')
|
|
.replace('/api/jsonrpc.php', '');
|
|
|
|
const projectUrl = baseUrl.endsWith('/')
|
|
? `${baseUrl}projects/showProject/${projectId}`
|
|
: `${baseUrl}/projects/showProject/${projectId}`;
|
|
|
|
console.log(`🔗 Project created successfully. Direct project URL: ${projectUrl}`);
|
|
|
|
if (!missionUsers || missionUsers.length === 0) {
|
|
console.log('No users to assign to the project.');
|
|
|
|
// Ensure at least the API user is assigned to prevent "Current team member is New API Access" issue
|
|
console.log('Ensuring API user is assigned to the project to prevent orphaned projects.');
|
|
const apiUserId = await this.getApiUserId();
|
|
if (apiUserId) {
|
|
try {
|
|
const apiAssigned = await this.assignApiUserToProject(projectId, apiUserId);
|
|
if (apiAssigned) {
|
|
console.log('API user successfully assigned to project as admin.');
|
|
}
|
|
} catch (apiUserError) {
|
|
console.error('Error assigning API user to project:', apiUserError);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Users will need to be added manually if the automatic assignment fails
|
|
console.log('Attempting to assign users to the project - if this fails, users can be added manually through the Leantime interface.');
|
|
|
|
try {
|
|
let successCount = 0;
|
|
let errorCount = 0;
|
|
|
|
for (const missionUser of missionUsers) {
|
|
try {
|
|
// Get or create the user in Leantime
|
|
const leantimeUserId = await this.getUserByEmail(missionUser.user.email);
|
|
if (!leantimeUserId) {
|
|
console.warn(`⚠️ User not found in Leantime: ${missionUser.user.email}`);
|
|
errorCount++;
|
|
continue;
|
|
}
|
|
|
|
// Determine role (Gardien du Temps gets editor, others get commenter)
|
|
const role = missionUser.role === 'gardien-temps' ? 'editor' : 'commenter';
|
|
|
|
// Assign the user to the project - IMPORTANT: Only increment success if assignment actually succeeds
|
|
const assignmentSucceeded = await this.assignUserToProject(projectId, leantimeUserId, role);
|
|
if (assignmentSucceeded) {
|
|
successCount++;
|
|
console.log(`✅ Successfully assigned user ${missionUser.user.email} (ID: ${leantimeUserId}) to project ${projectId} with role ${role}`);
|
|
} else {
|
|
errorCount++;
|
|
console.log(`❌ Failed to assign user ${missionUser.user.email} (ID: ${leantimeUserId}) to project ${projectId}`);
|
|
}
|
|
} catch (userError) {
|
|
console.error(`Error assigning user ${missionUser.user.email}:`, userError);
|
|
errorCount++;
|
|
// Continue with next user
|
|
}
|
|
}
|
|
|
|
// If no users were successfully assigned, assign the API user as a fallback
|
|
if (successCount === 0) {
|
|
console.log('No users successfully assigned. Adding API user as a fallback.');
|
|
const apiUserId = await this.getApiUserId();
|
|
if (apiUserId) {
|
|
try {
|
|
const apiAssigned = await this.assignApiUserToProject(projectId, apiUserId);
|
|
if (apiAssigned) {
|
|
successCount++;
|
|
console.log('✅ API user successfully assigned to project as admin.');
|
|
}
|
|
} catch (apiUserError) {
|
|
console.error('Error assigning API user to project:', apiUserError);
|
|
}
|
|
}
|
|
}
|
|
|
|
console.log(`User assignment complete: ${successCount} successful, ${errorCount} failed.`);
|
|
|
|
if (errorCount > 0) {
|
|
console.log(`⚠️ Some users could not be assigned automatically. They will need to be added manually at: ${projectUrl}`);
|
|
}
|
|
} catch (error) {
|
|
console.error('Error assigning users to project:', error);
|
|
console.log(`⚠️ Users will need to be added manually at: ${projectUrl}`);
|
|
|
|
// Always ensure the API user is assigned as a last resort
|
|
try {
|
|
const apiUserId = await this.getApiUserId();
|
|
if (apiUserId) {
|
|
const apiAssigned = await this.assignApiUserToProject(projectId, apiUserId);
|
|
if (apiAssigned) {
|
|
console.log('✅ API user assigned as fallback to prevent orphaned project.');
|
|
}
|
|
}
|
|
} catch (apiUserError) {
|
|
console.error('Error assigning API user as fallback:', apiUserError);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Special method to assign the API user to a project
|
|
* This uses different approaches to try to ensure success
|
|
* @returns true if assignment succeeded, false otherwise
|
|
*/
|
|
private async assignApiUserToProject(projectId: number, apiUserId: string): Promise<boolean> {
|
|
console.log(`Assigning API user ${apiUserId} to project ${projectId} as admin`);
|
|
|
|
// Try various methods to assign the API user
|
|
|
|
// Method 1: Direct API assignment
|
|
try {
|
|
const response = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.Projects.addUser',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
projectId: projectId,
|
|
userId: apiUserId,
|
|
role: 'admin' // API user gets admin to ensure full control
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response.data && response.data.result) {
|
|
console.log(`Successfully assigned API user to project ${projectId}`);
|
|
return true;
|
|
}
|
|
} catch (error) {
|
|
console.log('API user assignment method 1 failed, trying next method...');
|
|
}
|
|
|
|
// Method 2: editUserProjectRelations
|
|
try {
|
|
const response = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.editUserProjectRelations',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
action: 'add',
|
|
userId: apiUserId,
|
|
projects: [{
|
|
id: projectId,
|
|
role: 'admin'
|
|
}]
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response.data && response.data.result) {
|
|
console.log(`Successfully assigned API user to project ${projectId} (method 2)`);
|
|
return true;
|
|
}
|
|
} catch (error) {
|
|
console.log('API user assignment method 2 failed, trying next method...');
|
|
}
|
|
|
|
// Method 3: addProjectUser
|
|
try {
|
|
const response = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.addProjectUser',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
projectId: projectId,
|
|
userId: apiUserId,
|
|
role: 'admin'
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response.data && response.data.result) {
|
|
console.log(`Successfully assigned API user to project ${projectId} (method 3)`);
|
|
return true;
|
|
}
|
|
} catch (error) {
|
|
console.log('API user assignment method 3 failed.');
|
|
}
|
|
|
|
console.warn(`⚠️ Could not assign API user to project ${projectId}. The project may appear with "New API Access" as the only team member.`);
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Assign a user to a project with the specified role
|
|
* @param projectId The Leantime project ID
|
|
* @param userId The Leantime user ID
|
|
* @param role The role to assign
|
|
* @returns true if assignment succeeded, false otherwise
|
|
*/
|
|
async assignUserToProject(projectId: number, userId: string, role: string): Promise<boolean> {
|
|
try {
|
|
console.log(`Assigning user ${userId} to project ${projectId} with role ${role}`);
|
|
|
|
// Try method 1: Projects.Projects.addUser
|
|
try {
|
|
const response = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.Projects.addUser',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
projectId: projectId,
|
|
userId: userId,
|
|
role: role
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response.data && response.data.result) {
|
|
console.log(`Assigned user ${userId} to project ${projectId} with role ${role} (method 1)`);
|
|
return true;
|
|
}
|
|
} catch (error) {
|
|
console.log('Method 1 failed, trying next method...');
|
|
}
|
|
|
|
// Try method 2: Projects.addProjectUser
|
|
try {
|
|
const response2 = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.addProjectUser',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
projectId: projectId,
|
|
userId: userId,
|
|
role: role
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response2.data && response2.data.result) {
|
|
console.log(`Assigned user ${userId} to project ${projectId} with role ${role} (method 2)`);
|
|
return true;
|
|
}
|
|
} catch (error) {
|
|
console.log('Method 2 failed, trying next method...');
|
|
}
|
|
|
|
// Try method 3: Projects.Projects.addProjectUser
|
|
try {
|
|
const response3 = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.Projects.addProjectUser',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
projectId: projectId,
|
|
userId: userId,
|
|
role: role
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response3.data && response3.data.result) {
|
|
console.log(`Assigned user ${userId} to project ${projectId} with role ${role} (method 3)`);
|
|
return true;
|
|
}
|
|
} catch (error) {
|
|
console.log('Method 3 failed, trying next method...');
|
|
}
|
|
|
|
// Try method 4: Projects.editUserProjectRelations
|
|
try {
|
|
// This method might take a different param structure
|
|
const response4 = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.editUserProjectRelations',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
action: 'add',
|
|
userId: userId,
|
|
projects: [{
|
|
id: projectId,
|
|
role: role
|
|
}]
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response4.data && response4.data.result) {
|
|
console.log(`Assigned user ${userId} to project ${projectId} with role ${role} (method 4)`);
|
|
return true;
|
|
}
|
|
} catch (error) {
|
|
console.log('Method 4 failed.');
|
|
}
|
|
|
|
// If we reach here, all methods failed
|
|
console.warn(`⚠️ Could not assign user ${userId} to project ${projectId} with any method. This is not a critical error, the project was created.`);
|
|
return false;
|
|
|
|
} catch (error) {
|
|
console.error(`Error assigning user ${userId} to project ${projectId}:`, error);
|
|
// We'll allow this to fail since the project was created successfully
|
|
console.warn(`⚠️ User assignment failed, but this is not critical. The project ${projectId} was created successfully.`);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a client ID by name
|
|
* @param clientName The client name to search for
|
|
* @returns The client ID or null if not found
|
|
*/
|
|
async getClientIdByName(clientName: string): Promise<number | null> {
|
|
try {
|
|
// Log the API URL to debug
|
|
console.log('Leantime API URL:', this.apiUrl);
|
|
|
|
const apiEndpoint = this.getApiEndpoint();
|
|
console.log('Using endpoint:', apiEndpoint);
|
|
|
|
const response = await axios.post(
|
|
apiEndpoint,
|
|
{
|
|
method: 'leantime.rpc.Clients.Clients.getAll',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (!response.data || !response.data.result) {
|
|
throw new Error(`Failed to get clients: ${JSON.stringify(response.data)}`);
|
|
}
|
|
|
|
const clients = response.data.result;
|
|
const client = clients.find((c: any) =>
|
|
c.name.toLowerCase() === clientName.toLowerCase()
|
|
);
|
|
|
|
if (client) {
|
|
return parseInt(client.id);
|
|
} else {
|
|
console.log(`Client "${clientName}" not found. Creating it...`);
|
|
// Add delay before creating client to avoid rate limiting
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
return await this.createClient(clientName);
|
|
}
|
|
} catch (error) {
|
|
console.error('Error getting client by name:', error);
|
|
|
|
// Check if this is a rate limiting error
|
|
if (axios.isAxiosError(error) && error.response?.status === 429) {
|
|
console.log('Rate limiting detected (429). Waiting before retry...');
|
|
// Wait 2 seconds before next API call to respect rate limits
|
|
await new Promise(resolve => setTimeout(resolve, 2000));
|
|
}
|
|
|
|
// Try to create the client if we couldn't find it
|
|
try {
|
|
console.log(`Attempting to create client "${clientName}" after error...`);
|
|
return await this.createClient(clientName);
|
|
} catch (createError) {
|
|
console.error('Error creating client:', createError);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a new client in Leantime
|
|
* @param clientName The name of the client to create
|
|
* @returns The ID of the created client or null if failed
|
|
*/
|
|
async createClient(clientName: string): Promise<number | null> {
|
|
try {
|
|
const response = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Clients.Clients.create',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
values: {
|
|
name: clientName,
|
|
street: '',
|
|
zip: '',
|
|
city: '',
|
|
state: '',
|
|
country: '',
|
|
phone: '',
|
|
internet: '',
|
|
email: ''
|
|
}
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (!response.data || !response.data.result) {
|
|
throw new Error(`Failed to create client: ${JSON.stringify(response.data)}`);
|
|
}
|
|
|
|
const clientId = parseInt(response.data.result);
|
|
console.log(`Created client "${clientName}" with ID: ${clientId}`);
|
|
return clientId;
|
|
} catch (error) {
|
|
// Check if this is a rate limiting error
|
|
if (axios.isAxiosError(error) && error.response?.status === 429) {
|
|
console.log('Rate limiting detected (429). Waiting and retrying...');
|
|
// Wait 3 seconds and then retry
|
|
await new Promise(resolve => setTimeout(resolve, 3000));
|
|
|
|
try {
|
|
// Try again with a different API method name
|
|
const retryResponse = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Clients.Clients.addClient',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
values: {
|
|
name: clientName,
|
|
street: '',
|
|
zip: '',
|
|
city: '',
|
|
state: '',
|
|
country: '',
|
|
phone: '',
|
|
internet: '',
|
|
email: ''
|
|
}
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (retryResponse.data && retryResponse.data.result) {
|
|
const retryClientId = parseInt(retryResponse.data.result);
|
|
console.log(`Created client "${clientName}" with ID: ${retryClientId} (retry)`);
|
|
return retryClientId;
|
|
}
|
|
} catch (retryError) {
|
|
console.error('Error on retry:', retryError);
|
|
}
|
|
}
|
|
|
|
console.error(`Error creating client "${clientName}":`, error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a user ID by email
|
|
* @param email The user email to search for
|
|
* @returns The user ID or null if not found
|
|
*/
|
|
async getUserByEmail(email: string): Promise<string | null> {
|
|
try {
|
|
console.log(`Looking up user with email: ${email}`);
|
|
|
|
// Try getUserByEmail first (direct lookup method)
|
|
try {
|
|
const directResponse = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Users.Users.getUserByEmail',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
email: email
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (directResponse.data &&
|
|
directResponse.data.result &&
|
|
directResponse.data.result !== false &&
|
|
directResponse.data.result.id) {
|
|
console.log(`Found user by direct email lookup: ${directResponse.data.result.id}`);
|
|
return directResponse.data.result.id;
|
|
}
|
|
} catch (directError) {
|
|
console.log('Direct email lookup failed, trying alternate method...');
|
|
|
|
// Check if the error is rate limiting (429)
|
|
if (axios.isAxiosError(directError) && directError.response?.status === 429) {
|
|
console.log('Rate limiting detected (429). Waiting before retry...');
|
|
// Wait 1 second before next API call to respect rate limits
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
}
|
|
}
|
|
|
|
// Fall back to get all users and filter
|
|
try {
|
|
const response = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Users.Users.getAll',
|
|
jsonrpc: '2.0',
|
|
id: 1
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
if (!response.data || !response.data.result) {
|
|
throw new Error(`Failed to get users: ${JSON.stringify(response.data)}`);
|
|
}
|
|
|
|
const users = response.data.result;
|
|
|
|
// First try exact email match
|
|
let user = users.find((u: any) => u.email === email || u.username === email);
|
|
|
|
// If that fails, try case-insensitive match
|
|
if (!user) {
|
|
const lowerEmail = email.toLowerCase();
|
|
user = users.find((u: any) =>
|
|
(u.email && u.email.toLowerCase() === lowerEmail) ||
|
|
(u.username && u.username.toLowerCase() === lowerEmail)
|
|
);
|
|
}
|
|
|
|
if (user) {
|
|
console.log(`Found user with email ${email}: ID ${user.id}`);
|
|
return user.id;
|
|
}
|
|
} catch (fetchError) {
|
|
// Check if this is a rate limiting error
|
|
if (axios.isAxiosError(fetchError) && fetchError.response?.status === 429) {
|
|
console.log('Rate limiting detected (429). Consider user assignment through manual UI.');
|
|
} else {
|
|
console.error('Error fetching users:', fetchError);
|
|
}
|
|
}
|
|
|
|
// If user is still not found or error occurred
|
|
console.log(`No user found with email ${email}`);
|
|
return null;
|
|
} catch (error) {
|
|
console.error('Error getting user by email:', error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete a project from Leantime
|
|
* @param projectId The Leantime project ID to delete
|
|
* @returns True if successful, false otherwise
|
|
*/
|
|
async deleteProject(projectId: number): Promise<boolean> {
|
|
try {
|
|
const response = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.Projects.deleteProject',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
id: projectId
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
return response.data && response.data.result === true;
|
|
} catch (error) {
|
|
// Check if this is a rate limiting error
|
|
if (axios.isAxiosError(error) && error.response?.status === 429) {
|
|
console.log('Rate limiting detected (429) on delete. Waiting and retrying...');
|
|
|
|
// Wait 3 seconds and then retry
|
|
await new Promise(resolve => setTimeout(resolve, 3000));
|
|
|
|
try {
|
|
// Retry the delete
|
|
const retryResponse = await axios.post(
|
|
this.getApiEndpoint(),
|
|
{
|
|
method: 'leantime.rpc.Projects.Projects.deleteProject',
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
params: {
|
|
id: projectId
|
|
}
|
|
},
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-API-Key': this.apiToken
|
|
}
|
|
}
|
|
);
|
|
|
|
return retryResponse.data && retryResponse.data.result === true;
|
|
} catch (retryError) {
|
|
console.error(`Error on retry delete for project ${projectId}:`, retryError);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
console.error(`Error deleting Leantime project ${projectId}:`, error);
|
|
return false;
|
|
}
|
|
}
|
|
}
|