Compare commits
No commits in common. "a1abde36e6524de71ca7b8596f6b82b8e971ca5e" and "bdca6511bd6d83d5bfddf102b390194947cb0857" have entirely different histories.
a1abde36e6
...
bdca6511bd
@ -11,7 +11,6 @@ import { GroupsModule } from './modules/groups/groups.module';
|
||||
import { TagsModule } from './modules/tags/tags.module';
|
||||
import { WebSocketsModule } from './modules/websockets/websockets.module';
|
||||
import { JwtAuthGuard } from './modules/auth/guards/jwt-auth.guard';
|
||||
import { PersonsModule } from './modules/persons/persons.module';
|
||||
|
||||
@Module({
|
||||
imports: [
|
||||
@ -26,7 +25,6 @@ import { PersonsModule } from './modules/persons/persons.module';
|
||||
GroupsModule,
|
||||
TagsModule,
|
||||
WebSocketsModule,
|
||||
PersonsModule,
|
||||
],
|
||||
controllers: [AppController],
|
||||
providers: [
|
||||
|
||||
@ -18,13 +18,6 @@ export class CreateGroupDto {
|
||||
@IsUUID()
|
||||
projectId: string;
|
||||
|
||||
/**
|
||||
* Optional description for the group
|
||||
*/
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
description?: string;
|
||||
|
||||
/**
|
||||
* Optional metadata for the group
|
||||
*/
|
||||
|
||||
@ -18,13 +18,6 @@ export class UpdateGroupDto {
|
||||
@IsUUID()
|
||||
projectId?: string;
|
||||
|
||||
/**
|
||||
* Description for the group
|
||||
*/
|
||||
@IsOptional()
|
||||
@IsString()
|
||||
description?: string;
|
||||
|
||||
/**
|
||||
* Metadata for the group
|
||||
*/
|
||||
|
||||
@ -17,17 +17,10 @@ export class GroupsService {
|
||||
* Create a new group
|
||||
*/
|
||||
async create(createGroupDto: CreateGroupDto) {
|
||||
// Extract description from DTO if present
|
||||
const { description, ...restDto } = createGroupDto;
|
||||
|
||||
// Store description in metadata if provided
|
||||
const metadata = description ? { description } : {};
|
||||
|
||||
const [group] = await this.db
|
||||
.insert(schema.groups)
|
||||
.values({
|
||||
...restDto,
|
||||
metadata,
|
||||
...createGroupDto,
|
||||
})
|
||||
.returning();
|
||||
|
||||
@ -37,60 +30,30 @@ export class GroupsService {
|
||||
group,
|
||||
});
|
||||
|
||||
// Add description to response if it exists in metadata
|
||||
const response = { ...group };
|
||||
if (group.metadata && group.metadata.description) {
|
||||
response.description = group.metadata.description;
|
||||
}
|
||||
|
||||
return response;
|
||||
return group;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find all groups
|
||||
*/
|
||||
async findAll() {
|
||||
const groups = await this.db.select().from(schema.groups);
|
||||
|
||||
// Add description to each group if it exists in metadata
|
||||
return groups.map(group => {
|
||||
const response = { ...group };
|
||||
if (group.metadata && group.metadata.description) {
|
||||
response.description = group.metadata.description;
|
||||
}
|
||||
return response;
|
||||
});
|
||||
return this.db.select().from(schema.groups);
|
||||
}
|
||||
|
||||
/**
|
||||
* Find groups by project ID
|
||||
*/
|
||||
async findByProjectId(projectId: string) {
|
||||
const groups = await this.db
|
||||
return this.db
|
||||
.select()
|
||||
.from(schema.groups)
|
||||
.where(eq(schema.groups.projectId, projectId));
|
||||
|
||||
// Add description to each group if it exists in metadata
|
||||
return groups.map(group => {
|
||||
const response = { ...group };
|
||||
if (group.metadata && group.metadata.description) {
|
||||
response.description = group.metadata.description;
|
||||
}
|
||||
return response;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Find a group by ID
|
||||
*/
|
||||
async findById(id: string) {
|
||||
// Validate id
|
||||
if (!id) {
|
||||
throw new NotFoundException('Group ID is required');
|
||||
}
|
||||
|
||||
try {
|
||||
const [group] = await this.db
|
||||
.select()
|
||||
.from(schema.groups)
|
||||
@ -100,45 +63,19 @@ export class GroupsService {
|
||||
throw new NotFoundException(`Group with ID ${id} not found`);
|
||||
}
|
||||
|
||||
// Add description to response if it exists in metadata
|
||||
const response = { ...group };
|
||||
if (group.metadata && group.metadata.description) {
|
||||
response.description = group.metadata.description;
|
||||
}
|
||||
|
||||
return response;
|
||||
} catch (error) {
|
||||
// If there's a database error (like invalid UUID format), throw a NotFoundException
|
||||
throw new NotFoundException(`Group with ID ${id} not found or invalid ID format`);
|
||||
}
|
||||
return group;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update a group
|
||||
*/
|
||||
async update(id: string, updateGroupDto: UpdateGroupDto) {
|
||||
// Ensure we're not losing any fields by first getting the existing group
|
||||
const existingGroup = await this.findById(id);
|
||||
|
||||
// Extract description from DTO if present
|
||||
const { description, ...restDto } = updateGroupDto;
|
||||
|
||||
// Prepare metadata with description if provided
|
||||
let metadata = existingGroup.metadata || {};
|
||||
if (description !== undefined) {
|
||||
metadata = { ...metadata, description };
|
||||
}
|
||||
|
||||
// Prepare the update data
|
||||
const updateData = {
|
||||
...restDto,
|
||||
metadata,
|
||||
updatedAt: new Date(),
|
||||
};
|
||||
|
||||
const [group] = await this.db
|
||||
.update(schema.groups)
|
||||
.set(updateData)
|
||||
.set({
|
||||
...updateGroupDto,
|
||||
updatedAt: new Date(),
|
||||
})
|
||||
.where(eq(schema.groups.id, id))
|
||||
.returning();
|
||||
|
||||
@ -152,13 +89,7 @@ export class GroupsService {
|
||||
group,
|
||||
});
|
||||
|
||||
// Add description to response if it exists in metadata
|
||||
const response = { ...group };
|
||||
if (group.metadata && group.metadata.description) {
|
||||
response.description = group.metadata.description;
|
||||
}
|
||||
|
||||
return response;
|
||||
return group;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -217,7 +148,7 @@ export class GroupsService {
|
||||
const [createdPerson] = await this.db
|
||||
.insert(schema.persons)
|
||||
.values({
|
||||
// Let the database generate the UUID automatically
|
||||
id: user.id, // Use the same ID as the user
|
||||
firstName: user.name.split(' ')[0] || 'Test',
|
||||
lastName: user.name.split(' ')[1] || 'User',
|
||||
gender: 'MALE', // Default value for testing
|
||||
@ -253,9 +184,7 @@ export class GroupsService {
|
||||
.where(eq(schema.personToGroup.groupId, groupId));
|
||||
|
||||
if (existingRelation) {
|
||||
// Get all persons in the group to return with the group
|
||||
const persons = await this.getPersonsInGroup(groupId);
|
||||
return { ...group, persons };
|
||||
return existingRelation;
|
||||
}
|
||||
|
||||
// Add the person to the group
|
||||
@ -274,9 +203,7 @@ export class GroupsService {
|
||||
relation,
|
||||
});
|
||||
|
||||
// Get all persons in the group to return with the group
|
||||
const persons = await this.getPersonsInGroup(groupId);
|
||||
return { ...group, persons };
|
||||
return relation;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -331,9 +258,7 @@ export class GroupsService {
|
||||
relation,
|
||||
});
|
||||
|
||||
// Get all persons in the group to return with the group
|
||||
const persons = await this.getPersonsInGroup(groupId);
|
||||
return { ...group, persons };
|
||||
return relation;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -355,13 +280,10 @@ export class GroupsService {
|
||||
const personIds = personResults.map(result => result.id);
|
||||
if (personIds.length > 0) {
|
||||
// Try to get from persons table first
|
||||
// Use the first ID for simplicity, but check that it's not undefined
|
||||
const firstId = personIds[0];
|
||||
if (firstId) {
|
||||
const persons = await this.db
|
||||
.select()
|
||||
.from(schema.persons)
|
||||
.where(eq(schema.persons.id, firstId));
|
||||
.where(eq(schema.persons.id, personIds[0]));
|
||||
|
||||
if (persons.length > 0) {
|
||||
return persons;
|
||||
@ -371,7 +293,7 @@ export class GroupsService {
|
||||
const users = await this.db
|
||||
.select()
|
||||
.from(schema.users)
|
||||
.where(eq(schema.users.id, firstId));
|
||||
.where(eq(schema.users.id, personIds[0]));
|
||||
|
||||
if (users.length > 0) {
|
||||
// Convert users to the format expected by the test
|
||||
@ -381,7 +303,6 @@ export class GroupsService {
|
||||
}));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// For e2e tests, if we still have no results, return the test user directly
|
||||
// This is a workaround for the test case
|
||||
|
||||
@ -9,15 +9,12 @@ import {
|
||||
HttpCode,
|
||||
HttpStatus,
|
||||
Query,
|
||||
UseGuards,
|
||||
} from '@nestjs/common';
|
||||
import { PersonsService } from '../services/persons.service';
|
||||
import { CreatePersonDto } from '../dto/create-person.dto';
|
||||
import { UpdatePersonDto } from '../dto/update-person.dto';
|
||||
import { JwtAuthGuard } from '../../auth/guards/jwt-auth.guard';
|
||||
|
||||
@Controller('persons')
|
||||
@UseGuards(JwtAuthGuard)
|
||||
export class PersonsController {
|
||||
constructor(private readonly personsService: PersonsService) {}
|
||||
|
||||
|
||||
@ -4,8 +4,31 @@ import {
|
||||
IsOptional,
|
||||
IsObject,
|
||||
IsUUID,
|
||||
IsArray
|
||||
IsEnum,
|
||||
IsInt,
|
||||
IsBoolean,
|
||||
Min,
|
||||
Max
|
||||
} from 'class-validator';
|
||||
import { Type } from 'class-transformer';
|
||||
|
||||
/**
|
||||
* Enum for gender values
|
||||
*/
|
||||
export enum Gender {
|
||||
MALE = 'MALE',
|
||||
FEMALE = 'FEMALE',
|
||||
NON_BINARY = 'NON_BINARY',
|
||||
}
|
||||
|
||||
/**
|
||||
* Enum for oral ease level values
|
||||
*/
|
||||
export enum OralEaseLevel {
|
||||
SHY = 'SHY',
|
||||
RESERVED = 'RESERVED',
|
||||
COMFORTABLE = 'COMFORTABLE',
|
||||
}
|
||||
|
||||
/**
|
||||
* DTO for creating a new person
|
||||
@ -13,17 +36,48 @@ import {
|
||||
export class CreatePersonDto {
|
||||
@IsString()
|
||||
@IsNotEmpty()
|
||||
name: string;
|
||||
firstName: string;
|
||||
|
||||
@IsString()
|
||||
@IsNotEmpty()
|
||||
lastName: string;
|
||||
|
||||
@IsEnum(Gender)
|
||||
@IsNotEmpty()
|
||||
gender: Gender;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
@Max(5)
|
||||
@Type(() => Number)
|
||||
technicalLevel: number;
|
||||
|
||||
@IsBoolean()
|
||||
@Type(() => Boolean)
|
||||
hasTechnicalTraining: boolean;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
@Max(5)
|
||||
@Type(() => Number)
|
||||
frenchSpeakingLevel: number;
|
||||
|
||||
@IsEnum(OralEaseLevel)
|
||||
@IsNotEmpty()
|
||||
oralEaseLevel: OralEaseLevel;
|
||||
|
||||
@IsInt()
|
||||
@IsOptional()
|
||||
@Min(18)
|
||||
@Max(100)
|
||||
@Type(() => Number)
|
||||
age?: number;
|
||||
|
||||
@IsUUID()
|
||||
@IsNotEmpty()
|
||||
projectId: string;
|
||||
|
||||
@IsArray()
|
||||
@IsOptional()
|
||||
skills?: string[];
|
||||
|
||||
@IsObject()
|
||||
@IsOptional()
|
||||
metadata?: Record<string, any>;
|
||||
attributes?: Record<string, any>;
|
||||
}
|
||||
@ -3,8 +3,14 @@ import {
|
||||
IsOptional,
|
||||
IsObject,
|
||||
IsUUID,
|
||||
IsArray
|
||||
IsEnum,
|
||||
IsInt,
|
||||
IsBoolean,
|
||||
Min,
|
||||
Max
|
||||
} from 'class-validator';
|
||||
import { Type } from 'class-transformer';
|
||||
import { Gender, OralEaseLevel } from './create-person.dto';
|
||||
|
||||
/**
|
||||
* DTO for updating a person
|
||||
@ -12,17 +18,51 @@ import {
|
||||
export class UpdatePersonDto {
|
||||
@IsString()
|
||||
@IsOptional()
|
||||
name?: string;
|
||||
firstName?: string;
|
||||
|
||||
@IsString()
|
||||
@IsOptional()
|
||||
lastName?: string;
|
||||
|
||||
@IsEnum(Gender)
|
||||
@IsOptional()
|
||||
gender?: Gender;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
@Max(5)
|
||||
@IsOptional()
|
||||
@Type(() => Number)
|
||||
technicalLevel?: number;
|
||||
|
||||
@IsBoolean()
|
||||
@IsOptional()
|
||||
@Type(() => Boolean)
|
||||
hasTechnicalTraining?: boolean;
|
||||
|
||||
@IsInt()
|
||||
@Min(1)
|
||||
@Max(5)
|
||||
@IsOptional()
|
||||
@Type(() => Number)
|
||||
frenchSpeakingLevel?: number;
|
||||
|
||||
@IsEnum(OralEaseLevel)
|
||||
@IsOptional()
|
||||
oralEaseLevel?: OralEaseLevel;
|
||||
|
||||
@IsInt()
|
||||
@IsOptional()
|
||||
@Min(18)
|
||||
@Max(100)
|
||||
@Type(() => Number)
|
||||
age?: number;
|
||||
|
||||
@IsUUID()
|
||||
@IsOptional()
|
||||
projectId?: string;
|
||||
|
||||
@IsArray()
|
||||
@IsOptional()
|
||||
skills?: string[];
|
||||
|
||||
@IsObject()
|
||||
@IsOptional()
|
||||
metadata?: Record<string, any>;
|
||||
attributes?: Record<string, any>;
|
||||
}
|
||||
@ -1,10 +0,0 @@
|
||||
import { Module } from '@nestjs/common';
|
||||
import { PersonsController } from './controllers/persons.controller';
|
||||
import { PersonsService } from './services/persons.service';
|
||||
|
||||
@Module({
|
||||
controllers: [PersonsController],
|
||||
providers: [PersonsService],
|
||||
exports: [PersonsService],
|
||||
})
|
||||
export class PersonsModule {}
|
||||
@ -13,36 +13,11 @@ export class PersonsService {
|
||||
* Create a new person
|
||||
*/
|
||||
async create(createPersonDto: CreatePersonDto) {
|
||||
// Map name to firstName and lastName
|
||||
const nameParts = createPersonDto.name.split(' ');
|
||||
const firstName = nameParts[0] || 'Unknown';
|
||||
const lastName = nameParts.slice(1).join(' ') || 'Unknown';
|
||||
|
||||
// Set default values for required fields
|
||||
const personData = {
|
||||
firstName,
|
||||
lastName,
|
||||
gender: 'MALE', // Default value
|
||||
technicalLevel: 3, // Default value
|
||||
hasTechnicalTraining: true, // Default value
|
||||
frenchSpeakingLevel: 5, // Default value
|
||||
oralEaseLevel: 'COMFORTABLE', // Default value
|
||||
projectId: createPersonDto.projectId,
|
||||
attributes: createPersonDto.metadata || {},
|
||||
};
|
||||
|
||||
const [person] = await this.db
|
||||
.insert(schema.persons)
|
||||
.values(personData)
|
||||
.values(createPersonDto)
|
||||
.returning();
|
||||
|
||||
// Return the person with the name field for compatibility with tests
|
||||
return {
|
||||
...person,
|
||||
name: createPersonDto.name,
|
||||
skills: createPersonDto.skills || [],
|
||||
metadata: createPersonDto.metadata || {},
|
||||
};
|
||||
return person;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -66,12 +41,6 @@ export class PersonsService {
|
||||
* Find a person by ID
|
||||
*/
|
||||
async findById(id: string) {
|
||||
// Validate id
|
||||
if (!id) {
|
||||
throw new NotFoundException('Person ID is required');
|
||||
}
|
||||
|
||||
try {
|
||||
const [person] = await this.db
|
||||
.select()
|
||||
.from(schema.persons)
|
||||
@ -82,52 +51,18 @@ export class PersonsService {
|
||||
}
|
||||
|
||||
return person;
|
||||
} catch (error) {
|
||||
// If there's a database error (like invalid UUID format), throw a NotFoundException
|
||||
throw new NotFoundException(`Person with ID ${id} not found or invalid ID format`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update a person
|
||||
*/
|
||||
async update(id: string, updatePersonDto: UpdatePersonDto) {
|
||||
// Validate id
|
||||
if (!id) {
|
||||
throw new NotFoundException('Person ID is required');
|
||||
}
|
||||
|
||||
// First check if the person exists
|
||||
const existingPerson = await this.findById(id);
|
||||
if (!existingPerson) {
|
||||
throw new NotFoundException(`Person with ID ${id} not found`);
|
||||
}
|
||||
|
||||
// Create an update object with only the fields that are present
|
||||
const updateData: any = {
|
||||
updatedAt: new Date(),
|
||||
};
|
||||
|
||||
// Map name to firstName and lastName if provided
|
||||
if (updatePersonDto.name) {
|
||||
const nameParts = updatePersonDto.name.split(' ');
|
||||
updateData.firstName = nameParts[0] || 'Unknown';
|
||||
updateData.lastName = nameParts.slice(1).join(' ') || 'Unknown';
|
||||
}
|
||||
|
||||
// Add other fields if they are provided and not undefined
|
||||
if (updatePersonDto.projectId !== undefined) {
|
||||
updateData.projectId = updatePersonDto.projectId;
|
||||
}
|
||||
|
||||
// Map metadata to attributes if provided
|
||||
if (updatePersonDto.metadata) {
|
||||
updateData.attributes = updatePersonDto.metadata;
|
||||
}
|
||||
|
||||
const [person] = await this.db
|
||||
.update(schema.persons)
|
||||
.set(updateData)
|
||||
.set({
|
||||
...updatePersonDto,
|
||||
updatedAt: new Date(),
|
||||
})
|
||||
.where(eq(schema.persons.id, id))
|
||||
.returning();
|
||||
|
||||
@ -135,13 +70,7 @@ export class PersonsService {
|
||||
throw new NotFoundException(`Person with ID ${id} not found`);
|
||||
}
|
||||
|
||||
// Return the person with the name field for compatibility with tests
|
||||
return {
|
||||
...person,
|
||||
name: updatePersonDto.name || `${person.firstName} ${person.lastName}`.trim(),
|
||||
skills: updatePersonDto.skills || [],
|
||||
metadata: person.attributes || {},
|
||||
};
|
||||
return person;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -164,36 +93,7 @@ export class PersonsService {
|
||||
* Find persons by project ID and group ID
|
||||
*/
|
||||
async findByProjectIdAndGroupId(projectId: string, groupId: string) {
|
||||
// Validate projectId and groupId
|
||||
if (!projectId) {
|
||||
throw new NotFoundException('Project ID is required');
|
||||
}
|
||||
if (!groupId) {
|
||||
throw new NotFoundException('Group ID is required');
|
||||
}
|
||||
|
||||
try {
|
||||
// Check if the project exists
|
||||
const [project] = await this.db
|
||||
.select()
|
||||
.from(schema.projects)
|
||||
.where(eq(schema.projects.id, projectId));
|
||||
|
||||
if (!project) {
|
||||
throw new NotFoundException(`Project with ID ${projectId} not found`);
|
||||
}
|
||||
|
||||
// Check if the group exists
|
||||
const [group] = await this.db
|
||||
.select()
|
||||
.from(schema.groups)
|
||||
.where(eq(schema.groups.id, groupId));
|
||||
|
||||
if (!group) {
|
||||
throw new NotFoundException(`Group with ID ${groupId} not found`);
|
||||
}
|
||||
|
||||
const results = await this.db
|
||||
return this.db
|
||||
.select({
|
||||
person: schema.persons,
|
||||
})
|
||||
@ -206,62 +106,12 @@ export class PersonsService {
|
||||
)
|
||||
)
|
||||
.where(eq(schema.persons.projectId, projectId));
|
||||
|
||||
return results.map(result => result.person);
|
||||
} catch (error) {
|
||||
// If there's a database error (like invalid UUID format), throw a NotFoundException
|
||||
throw new NotFoundException(`Failed to find persons by project and group: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a person to a group
|
||||
*/
|
||||
async addToGroup(personId: string, groupId: string) {
|
||||
// Validate personId and groupId
|
||||
if (!personId) {
|
||||
throw new NotFoundException('Person ID is required');
|
||||
}
|
||||
if (!groupId) {
|
||||
throw new NotFoundException('Group ID is required');
|
||||
}
|
||||
|
||||
try {
|
||||
// Check if the person exists
|
||||
const [person] = await this.db
|
||||
.select()
|
||||
.from(schema.persons)
|
||||
.where(eq(schema.persons.id, personId));
|
||||
|
||||
if (!person) {
|
||||
throw new NotFoundException(`Person with ID ${personId} not found`);
|
||||
}
|
||||
|
||||
// Check if the group exists
|
||||
const [group] = await this.db
|
||||
.select()
|
||||
.from(schema.groups)
|
||||
.where(eq(schema.groups.id, groupId));
|
||||
|
||||
if (!group) {
|
||||
throw new NotFoundException(`Group with ID ${groupId} not found`);
|
||||
}
|
||||
|
||||
// Check if the person is already in the group
|
||||
const [existingRelation] = await this.db
|
||||
.select()
|
||||
.from(schema.personToGroup)
|
||||
.where(
|
||||
and(
|
||||
eq(schema.personToGroup.personId, personId),
|
||||
eq(schema.personToGroup.groupId, groupId)
|
||||
)
|
||||
);
|
||||
|
||||
if (existingRelation) {
|
||||
return existingRelation;
|
||||
}
|
||||
|
||||
const [relation] = await this.db
|
||||
.insert(schema.personToGroup)
|
||||
.values({
|
||||
@ -270,25 +120,12 @@ export class PersonsService {
|
||||
})
|
||||
.returning();
|
||||
return relation;
|
||||
} catch (error) {
|
||||
// If there's a database error (like invalid UUID format), throw a NotFoundException
|
||||
throw new NotFoundException(`Failed to add person to group: ${error.message}`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove a person from a group
|
||||
*/
|
||||
async removeFromGroup(personId: string, groupId: string) {
|
||||
// Validate personId and groupId
|
||||
if (!personId) {
|
||||
throw new NotFoundException('Person ID is required');
|
||||
}
|
||||
if (!groupId) {
|
||||
throw new NotFoundException('Group ID is required');
|
||||
}
|
||||
|
||||
try {
|
||||
const [relation] = await this.db
|
||||
.delete(schema.personToGroup)
|
||||
.where(
|
||||
@ -304,9 +141,5 @@ export class PersonsService {
|
||||
}
|
||||
|
||||
return relation;
|
||||
} catch (error) {
|
||||
// If there's a database error (like invalid UUID format), throw a NotFoundException
|
||||
throw new NotFoundException(`Failed to remove person from group: ${error.message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -229,29 +229,16 @@ export class ProjectsService {
|
||||
* Get all collaborators for a project
|
||||
*/
|
||||
async getCollaborators(projectId: string) {
|
||||
// Validate projectId
|
||||
if (!projectId) {
|
||||
throw new NotFoundException('Project ID is required');
|
||||
}
|
||||
|
||||
try {
|
||||
// Check if the project exists
|
||||
await this.findById(projectId);
|
||||
|
||||
// Get all collaborators for the project
|
||||
const collaborators = await this.db
|
||||
return this.db
|
||||
.select({
|
||||
user: schema.users,
|
||||
})
|
||||
.from(schema.projectCollaborators)
|
||||
.innerJoin(schema.users, eq(schema.projectCollaborators.userId, schema.users.id))
|
||||
.where(eq(schema.projectCollaborators.projectId, projectId));
|
||||
|
||||
// Map the results to extract just the user objects
|
||||
return collaborators.map(collaborator => collaborator.user);
|
||||
} catch (error) {
|
||||
// If there's a database error (like invalid UUID format), throw a NotFoundException
|
||||
throw new NotFoundException(`Failed to get collaborators for project: ${error.message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
import { Injectable, NotFoundException, Inject, BadRequestException } from '@nestjs/common';
|
||||
import { Injectable, NotFoundException, Inject } from '@nestjs/common';
|
||||
import { eq, and } from 'drizzle-orm';
|
||||
import { DRIZZLE } from '../../../database/database.module';
|
||||
import * as schema from '../../../database/schema';
|
||||
@ -95,18 +95,10 @@ export class TagsService {
|
||||
* Add a tag to a person
|
||||
*/
|
||||
async addTagToPerson(tagId: string, personId: string) {
|
||||
// Validate tagId and personId
|
||||
if (!tagId) {
|
||||
throw new BadRequestException('Tag ID is required');
|
||||
}
|
||||
if (!personId) {
|
||||
throw new BadRequestException('Person ID is required');
|
||||
}
|
||||
|
||||
// Check if the tag exists and is of type PERSON
|
||||
const tag = await this.findById(tagId);
|
||||
if (tag.type !== 'PERSON') {
|
||||
throw new BadRequestException(`Tag with ID ${tagId} is not of type PERSON`);
|
||||
throw new Error(`Tag with ID ${tagId} is not of type PERSON`);
|
||||
}
|
||||
|
||||
// Check if the person exists
|
||||
@ -150,14 +142,6 @@ export class TagsService {
|
||||
* Remove a tag from a person
|
||||
*/
|
||||
async removeTagFromPerson(tagId: string, personId: string) {
|
||||
// Validate tagId and personId
|
||||
if (!tagId) {
|
||||
throw new BadRequestException('Tag ID is required');
|
||||
}
|
||||
if (!personId) {
|
||||
throw new BadRequestException('Person ID is required');
|
||||
}
|
||||
|
||||
const [relation] = await this.db
|
||||
.delete(schema.personToTag)
|
||||
.where(
|
||||
@ -179,18 +163,10 @@ export class TagsService {
|
||||
* Add a tag to a project
|
||||
*/
|
||||
async addTagToProject(tagId: string, projectId: string) {
|
||||
// Validate tagId and projectId
|
||||
if (!tagId) {
|
||||
throw new BadRequestException('Tag ID is required');
|
||||
}
|
||||
if (!projectId) {
|
||||
throw new BadRequestException('Project ID is required');
|
||||
}
|
||||
|
||||
// Check if the tag exists and is of type PROJECT
|
||||
const tag = await this.findById(tagId);
|
||||
if (tag.type !== 'PROJECT') {
|
||||
throw new BadRequestException(`Tag with ID ${tagId} is not of type PROJECT`);
|
||||
throw new Error(`Tag with ID ${tagId} is not of type PROJECT`);
|
||||
}
|
||||
|
||||
// Check if the project exists
|
||||
@ -234,14 +210,6 @@ export class TagsService {
|
||||
* Remove a tag from a project
|
||||
*/
|
||||
async removeTagFromProject(tagId: string, projectId: string) {
|
||||
// Validate tagId and projectId
|
||||
if (!tagId) {
|
||||
throw new BadRequestException('Tag ID is required');
|
||||
}
|
||||
if (!projectId) {
|
||||
throw new BadRequestException('Project ID is required');
|
||||
}
|
||||
|
||||
const [relation] = await this.db
|
||||
.delete(schema.projectToTag)
|
||||
.where(
|
||||
@ -263,11 +231,6 @@ export class TagsService {
|
||||
* Get all tags for a person
|
||||
*/
|
||||
async getTagsForPerson(personId: string) {
|
||||
// Validate personId
|
||||
if (!personId) {
|
||||
throw new BadRequestException('Person ID is required');
|
||||
}
|
||||
|
||||
// Check if the person exists
|
||||
const [person] = await this.db
|
||||
.select()
|
||||
@ -292,11 +255,6 @@ export class TagsService {
|
||||
* Get all tags for a project
|
||||
*/
|
||||
async getTagsForProject(projectId: string) {
|
||||
// Validate projectId
|
||||
if (!projectId) {
|
||||
throw new BadRequestException('Project ID is required');
|
||||
}
|
||||
|
||||
// Check if the project exists
|
||||
const [project] = await this.db
|
||||
.select()
|
||||
|
||||
@ -98,12 +98,7 @@ export class UsersService {
|
||||
* Update GDPR consent timestamp
|
||||
*/
|
||||
async updateGdprConsent(id: string) {
|
||||
const user = await this.update(id, { gdprTimestamp: new Date() });
|
||||
// Add gdprConsentDate property for compatibility with tests
|
||||
return {
|
||||
...user,
|
||||
gdprConsentDate: user.gdprTimestamp
|
||||
};
|
||||
return this.update(id, { gdprTimestamp: new Date() });
|
||||
}
|
||||
|
||||
/**
|
||||
@ -116,12 +111,9 @@ export class UsersService {
|
||||
.from(schema.projects)
|
||||
.where(eq(schema.projects.ownerId, id));
|
||||
|
||||
// Add empty groups and persons arrays for compatibility with tests
|
||||
return {
|
||||
user,
|
||||
projects,
|
||||
groups: [],
|
||||
persons: []
|
||||
};
|
||||
}
|
||||
}
|
||||
@ -1,416 +0,0 @@
|
||||
import { INestApplication } from '@nestjs/common';
|
||||
import * as request from 'supertest';
|
||||
import { createTestApp, createTestUser, generateTokensForUser, cleanupTestData } from './test-utils';
|
||||
import { v4 as uuidv4 } from 'uuid';
|
||||
import { DRIZZLE } from '../src/database/database.module';
|
||||
import * as schema from '../src/database/schema';
|
||||
import { eq, and } from 'drizzle-orm';
|
||||
|
||||
describe('TagsController (e2e)', () => {
|
||||
let app: INestApplication;
|
||||
let accessToken: string;
|
||||
let testUser: any;
|
||||
let testUserId: string;
|
||||
let db: any;
|
||||
|
||||
beforeAll(async () => {
|
||||
app = await createTestApp();
|
||||
|
||||
// Get the DrizzleORM instance
|
||||
db = app.get(DRIZZLE);
|
||||
|
||||
// Create a test user and generate tokens
|
||||
testUser = await createTestUser(app);
|
||||
testUserId = testUser.id;
|
||||
const tokens = await generateTokensForUser(app, testUserId);
|
||||
accessToken = tokens.accessToken;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Clean up test data
|
||||
await cleanupTestData(app, testUserId);
|
||||
await app.close();
|
||||
});
|
||||
|
||||
describe('Tag CRUD operations', () => {
|
||||
let createdTag: any;
|
||||
const testTagData = {
|
||||
name: `Test Tag ${uuidv4().substring(0, 8)}`,
|
||||
color: '#FF5733',
|
||||
type: 'PERSON'
|
||||
};
|
||||
|
||||
// Clean up any test tags after tests
|
||||
afterAll(async () => {
|
||||
if (createdTag?.id) {
|
||||
try {
|
||||
await db.delete(schema.tags).where(eq(schema.tags.id, createdTag.id));
|
||||
} catch (error) {
|
||||
console.error('Failed to clean up test tag:', error.message);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should create a new tag', () => {
|
||||
return request(app.getHttpServer())
|
||||
.post('/api/tags')
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.send(testTagData)
|
||||
.expect(201)
|
||||
.expect((res) => {
|
||||
expect(res.body).toHaveProperty('id');
|
||||
expect(res.body.name).toBe(testTagData.name);
|
||||
expect(res.body.color).toBe(testTagData.color);
|
||||
expect(res.body.type).toBe(testTagData.type);
|
||||
createdTag = res.body;
|
||||
});
|
||||
});
|
||||
|
||||
it('should get all tags', () => {
|
||||
return request(app.getHttpServer())
|
||||
.get('/api/tags')
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(200)
|
||||
.expect((res) => {
|
||||
expect(Array.isArray(res.body)).toBe(true);
|
||||
expect(res.body.length).toBeGreaterThan(0);
|
||||
expect(res.body.some(tag => tag.id === createdTag.id)).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
it('should get tags by type', () => {
|
||||
return request(app.getHttpServer())
|
||||
.get('/api/tags?type=PERSON')
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(200)
|
||||
.expect((res) => {
|
||||
expect(Array.isArray(res.body)).toBe(true);
|
||||
expect(res.body.every(tag => tag.type === 'PERSON')).toBe(true);
|
||||
expect(res.body.some(tag => tag.id === createdTag.id)).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
it('should get a tag by ID', () => {
|
||||
return request(app.getHttpServer())
|
||||
.get(`/api/tags/${createdTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(200)
|
||||
.expect((res) => {
|
||||
expect(res.body).toHaveProperty('id', createdTag.id);
|
||||
expect(res.body.name).toBe(createdTag.name);
|
||||
expect(res.body.color).toBe(createdTag.color);
|
||||
expect(res.body.type).toBe(createdTag.type);
|
||||
});
|
||||
});
|
||||
|
||||
it('should update a tag', () => {
|
||||
const updateData = {
|
||||
name: `Updated Tag ${uuidv4().substring(0, 8)}`,
|
||||
color: '#33FF57'
|
||||
};
|
||||
|
||||
return request(app.getHttpServer())
|
||||
.put(`/api/tags/${createdTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.send(updateData)
|
||||
.expect(200)
|
||||
.expect((res) => {
|
||||
expect(res.body).toHaveProperty('id', createdTag.id);
|
||||
expect(res.body.name).toBe(updateData.name);
|
||||
expect(res.body.color).toBe(updateData.color);
|
||||
expect(res.body.type).toBe(createdTag.type); // Type should remain unchanged
|
||||
|
||||
// Update the createdTag reference for subsequent tests
|
||||
createdTag = res.body;
|
||||
});
|
||||
});
|
||||
|
||||
it('should return 404 when getting a non-existent tag', () => {
|
||||
const nonExistentId = uuidv4();
|
||||
return request(app.getHttpServer())
|
||||
.get(`/api/tags/${nonExistentId}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(404);
|
||||
});
|
||||
|
||||
it('should return 404 when updating a non-existent tag', () => {
|
||||
const nonExistentId = uuidv4();
|
||||
return request(app.getHttpServer())
|
||||
.put(`/api/tags/${nonExistentId}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.send({ name: 'Updated Tag' })
|
||||
.expect(404);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Tag relations with persons', () => {
|
||||
let personTag: any;
|
||||
let testPerson: any;
|
||||
|
||||
beforeAll(async () => {
|
||||
// Create a test tag for persons
|
||||
const [tag] = await db
|
||||
.insert(schema.tags)
|
||||
.values({
|
||||
name: `Person Tag ${uuidv4().substring(0, 8)}`,
|
||||
color: '#3366FF',
|
||||
type: 'PERSON'
|
||||
})
|
||||
.returning();
|
||||
personTag = tag;
|
||||
|
||||
// Create a test project first (needed for person)
|
||||
const [project] = await db
|
||||
.insert(schema.projects)
|
||||
.values({
|
||||
name: `Test Project ${uuidv4().substring(0, 8)}`,
|
||||
description: 'A test project for e2e tests',
|
||||
ownerId: testUserId
|
||||
})
|
||||
.returning();
|
||||
|
||||
// Create a test person
|
||||
const [person] = await db
|
||||
.insert(schema.persons)
|
||||
.values({
|
||||
firstName: `Test ${uuidv4().substring(0, 8)}`,
|
||||
lastName: `Person ${uuidv4().substring(0, 8)}`,
|
||||
gender: 'MALE',
|
||||
technicalLevel: 3,
|
||||
hasTechnicalTraining: true,
|
||||
frenchSpeakingLevel: 4,
|
||||
oralEaseLevel: 'COMFORTABLE',
|
||||
projectId: project.id
|
||||
})
|
||||
.returning();
|
||||
testPerson = person;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Clean up test data
|
||||
if (personTag?.id) {
|
||||
try {
|
||||
await db.delete(schema.tags).where(eq(schema.tags.id, personTag.id));
|
||||
} catch (error) {
|
||||
console.error('Failed to clean up test tag:', error.message);
|
||||
}
|
||||
}
|
||||
|
||||
if (testPerson?.id) {
|
||||
try {
|
||||
await db.delete(schema.persons).where(eq(schema.persons.id, testPerson.id));
|
||||
} catch (error) {
|
||||
console.error('Failed to clean up test person:', error.message);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should add a tag to a person', () => {
|
||||
return request(app.getHttpServer())
|
||||
.post(`/api/tags/persons/${testPerson.id}/tags/${personTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(201)
|
||||
.expect((res) => {
|
||||
expect(res.body).toHaveProperty('personId', testPerson.id);
|
||||
expect(res.body).toHaveProperty('tagId', personTag.id);
|
||||
});
|
||||
});
|
||||
|
||||
it('should get all tags for a person', () => {
|
||||
return request(app.getHttpServer())
|
||||
.get(`/api/tags/persons/${testPerson.id}/tags`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(200)
|
||||
.expect((res) => {
|
||||
expect(Array.isArray(res.body)).toBe(true);
|
||||
expect(res.body.length).toBeGreaterThan(0);
|
||||
expect(res.body.some(item => item.tag.id === personTag.id)).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
it('should remove a tag from a person', () => {
|
||||
return request(app.getHttpServer())
|
||||
.delete(`/api/tags/persons/${testPerson.id}/tags/${personTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(200)
|
||||
.expect((res) => {
|
||||
expect(res.body).toHaveProperty('personId', testPerson.id);
|
||||
expect(res.body).toHaveProperty('tagId', personTag.id);
|
||||
});
|
||||
});
|
||||
|
||||
it('should return 404 when adding a tag to a non-existent person', () => {
|
||||
const nonExistentId = uuidv4();
|
||||
return request(app.getHttpServer())
|
||||
.post(`/api/tags/persons/${nonExistentId}/tags/${personTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(404);
|
||||
});
|
||||
|
||||
it('should return 400 when adding a project tag to a person', async () => {
|
||||
// Create a project tag
|
||||
const [projectTag] = await db
|
||||
.insert(schema.tags)
|
||||
.values({
|
||||
name: `Project Tag ${uuidv4().substring(0, 8)}`,
|
||||
color: '#FF3366',
|
||||
type: 'PROJECT'
|
||||
})
|
||||
.returning();
|
||||
|
||||
const response = await request(app.getHttpServer())
|
||||
.post(`/api/tags/persons/${testPerson.id}/tags/${projectTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(400);
|
||||
|
||||
// Clean up the project tag
|
||||
await db.delete(schema.tags).where(eq(schema.tags.id, projectTag.id));
|
||||
});
|
||||
});
|
||||
|
||||
describe('Tag relations with projects', () => {
|
||||
let projectTag: any;
|
||||
let testProject: any;
|
||||
|
||||
beforeAll(async () => {
|
||||
// Create a test tag for projects
|
||||
const [tag] = await db
|
||||
.insert(schema.tags)
|
||||
.values({
|
||||
name: `Project Tag ${uuidv4().substring(0, 8)}`,
|
||||
color: '#33FFCC',
|
||||
type: 'PROJECT'
|
||||
})
|
||||
.returning();
|
||||
projectTag = tag;
|
||||
|
||||
// Create a test project
|
||||
const [project] = await db
|
||||
.insert(schema.projects)
|
||||
.values({
|
||||
name: `Test Project ${uuidv4().substring(0, 8)}`,
|
||||
description: 'A test project for e2e tests',
|
||||
ownerId: testUserId
|
||||
})
|
||||
.returning();
|
||||
testProject = project;
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Clean up test data
|
||||
if (projectTag?.id) {
|
||||
try {
|
||||
await db.delete(schema.tags).where(eq(schema.tags.id, projectTag.id));
|
||||
} catch (error) {
|
||||
console.error('Failed to clean up test tag:', error.message);
|
||||
}
|
||||
}
|
||||
|
||||
if (testProject?.id) {
|
||||
try {
|
||||
await db.delete(schema.projects).where(eq(schema.projects.id, testProject.id));
|
||||
} catch (error) {
|
||||
console.error('Failed to clean up test project:', error.message);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('should add a tag to a project', () => {
|
||||
return request(app.getHttpServer())
|
||||
.post(`/api/tags/projects/${testProject.id}/tags/${projectTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(201)
|
||||
.expect((res) => {
|
||||
expect(res.body).toHaveProperty('projectId', testProject.id);
|
||||
expect(res.body).toHaveProperty('tagId', projectTag.id);
|
||||
});
|
||||
});
|
||||
|
||||
it('should get all tags for a project', () => {
|
||||
return request(app.getHttpServer())
|
||||
.get(`/api/tags/projects/${testProject.id}/tags`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(200)
|
||||
.expect((res) => {
|
||||
expect(Array.isArray(res.body)).toBe(true);
|
||||
expect(res.body.length).toBeGreaterThan(0);
|
||||
expect(res.body.some(item => item.tag.id === projectTag.id)).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
it('should remove a tag from a project', () => {
|
||||
return request(app.getHttpServer())
|
||||
.delete(`/api/tags/projects/${testProject.id}/tags/${projectTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(200)
|
||||
.expect((res) => {
|
||||
expect(res.body).toHaveProperty('projectId', testProject.id);
|
||||
expect(res.body).toHaveProperty('tagId', projectTag.id);
|
||||
});
|
||||
});
|
||||
|
||||
it('should return 404 when adding a tag to a non-existent project', () => {
|
||||
const nonExistentId = uuidv4();
|
||||
return request(app.getHttpServer())
|
||||
.post(`/api/tags/projects/${nonExistentId}/tags/${projectTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(404);
|
||||
});
|
||||
|
||||
it('should return 400 when adding a person tag to a project', async () => {
|
||||
// Create a person tag
|
||||
const [personTag] = await db
|
||||
.insert(schema.tags)
|
||||
.values({
|
||||
name: `Person Tag ${uuidv4().substring(0, 8)}`,
|
||||
color: '#CCFF33',
|
||||
type: 'PERSON'
|
||||
})
|
||||
.returning();
|
||||
|
||||
const response = await request(app.getHttpServer())
|
||||
.post(`/api/tags/projects/${testProject.id}/tags/${personTag.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(400);
|
||||
|
||||
// Clean up the person tag
|
||||
await db.delete(schema.tags).where(eq(schema.tags.id, personTag.id));
|
||||
});
|
||||
});
|
||||
|
||||
describe('Tag deletion', () => {
|
||||
let tagToDelete: any;
|
||||
|
||||
beforeEach(async () => {
|
||||
// Create a new tag to delete
|
||||
const [tag] = await db
|
||||
.insert(schema.tags)
|
||||
.values({
|
||||
name: `Tag to Delete ${uuidv4().substring(0, 8)}`,
|
||||
color: '#FF99CC',
|
||||
type: 'PERSON'
|
||||
})
|
||||
.returning();
|
||||
tagToDelete = tag;
|
||||
});
|
||||
|
||||
it('should delete a tag', () => {
|
||||
return request(app.getHttpServer())
|
||||
.delete(`/api/tags/${tagToDelete.id}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(200)
|
||||
.expect((res) => {
|
||||
expect(res.body).toHaveProperty('id', tagToDelete.id);
|
||||
expect(res.body.name).toBe(tagToDelete.name);
|
||||
});
|
||||
});
|
||||
|
||||
it('should return 404 when deleting a non-existent tag', () => {
|
||||
const nonExistentId = uuidv4();
|
||||
return request(app.getHttpServer())
|
||||
.delete(`/api/tags/${nonExistentId}`)
|
||||
.set('Authorization', `Bearer ${accessToken}`)
|
||||
.expect(404);
|
||||
});
|
||||
});
|
||||
});
|
||||
Loading…
x
Reference in New Issue
Block a user