feat: enable filters config and scientific conditions on the backend

src/users/dto/create-user-settings.dto.ts

@@ -1,7 +1,9 @@
 import { ApiProperty } from "@nestjs/swagger";
 import { UpdateUserSettingsDto } from "./update-user-settings.dto";
+import { IsString } from "class-validator";
 
 export class CreateUserSettingsDto extends UpdateUserSettingsDto {
   @ApiProperty({ type: String, required: true })
+  @IsString()
   readonly userId: string;
 }

src/users/dto/update-user-settings.dto.ts

@@ -1,14 +1,30 @@
 import { ApiProperty, PartialType } from "@nestjs/swagger";
+import {
+  FilterConfig,
+  ScientificCondition,
+} from "../schemas/user-settings.schema";
+import { IsArray, IsNumber } from "class-validator";
 
 export class UpdateUserSettingsDto {
   @ApiProperty()
+  @IsArray()
   readonly columns: Record<string, unknown>[];
 
   @ApiProperty({ type: Number, required: false, default: 25 })
+  @IsNumber()
   readonly datasetCount?: number;
 
   @ApiProperty({ type: Number, required: false, default: 25 })
+  @IsNumber()
   readonly jobCount?: number;
+
+  @ApiProperty()
+  @IsArray()
+  readonly filters: FilterConfig[];
+
+  @ApiProperty()
+  @IsArray()
+  readonly conditions: ScientificCondition[];
 }
 
 export class PartialUpdateUserSettingsDto extends PartialType(

src/users/interceptors/create-user-settings.interceptor.ts

@@ -8,6 +8,7 @@ import {
 import { Observable, tap } from "rxjs";
 import { CreateUserSettingsDto } from "../dto/create-user-settings.dto";
 import { UsersService } from "../users.service";
+import { kDefaultFilters } from "../schemas/user-settings.schema";
 
 @Injectable()
 export class CreateUserSettingsInterceptor implements NestInterceptor {
@@ -34,6 +35,8 @@ export class CreateUserSettingsInterceptor implements NestInterceptor {
           const createUserSettingsDto: CreateUserSettingsDto = {
             userId,
             columns: [],
+            filters: kDefaultFilters,
+            conditions: [],
           };
           return this.usersService.createUserSettings(
             userId,

src/users/interceptors/default-user-settings.interceptor.ts

@@ -0,0 +1,34 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  Logger,
+  NestInterceptor,
+} from "@nestjs/common";
+import { map, Observable, tap } from "rxjs";
+import { CreateUserSettingsDto } from "../dto/create-user-settings.dto";
+import { UsersService } from "../users.service";
+import { kDefaultFilters } from "../schemas/user-settings.schema";
+import { UpdateUserSettingsDto } from "../dto/update-user-settings.dto";
+
+@Injectable()
+export class DefaultUserSettingsInterceptor implements NestInterceptor {
+  constructor(private usersService: UsersService) {}
+  async intercept(
+    context: ExecutionContext,
+    next: CallHandler,
+  ): Promise<Observable<unknown>> {
+    return next.handle().pipe(
+      map(async () => {
+        Logger.log("DefaultUserSettingsInterceptor");
+        const defaultUserSettings: UpdateUserSettingsDto = {
+          columns: [],
+          filters: kDefaultFilters,
+          conditions: [],
+        };
+        console.log(defaultUserSettings);
+        return defaultUserSettings;
+      }),
+    );
+  }
+}

src/users/schemas/user-settings.schema.ts

@@ -5,6 +5,43 @@ import { Document } from "mongoose";
 
 export type UserSettingsDocument = UserSettings & Document;
 
+// Define possible filter component types as a union of string literals
+export type FilterComponentType =
+  | "LocationFilterComponent"
+  | "PidFilterComponent"
+  | "PidFilterContainsComponent"
+  | "PidFilterStartsWithComponent"
+  | "GroupFilterComponent"
+  | "TypeFilterComponent"
+  | "KeywordFilterComponent"
+  | "DateRangeFilterComponent"
+  | "TextFilterComponent";
+
+// Define the Filter interface
+export interface FilterConfig {
+  type: FilterComponentType;
+  visible: boolean;
+}
+
+// Define the Condition interface
+export interface ScientificCondition {
+  field: string;
+  value: string;
+  operator: string;
+}
+
+export const kDefaultFilters: FilterConfig[] = [
+  { type: "LocationFilterComponent", visible: true },
+  { type: "PidFilterComponent", visible: true },
+  { type: "PidFilterContainsComponent", visible: false },
+  { type: "PidFilterStartsWithComponent", visible: false },
+  { type: "GroupFilterComponent", visible: true },
+  { type: "TypeFilterComponent", visible: true },
+  { type: "KeywordFilterComponent", visible: true },
+  { type: "DateRangeFilterComponent", visible: true },
+  { type: "TextFilterComponent", visible: true },
+];
+
 @Schema({
   collection: "UserSetting",
   toJSON: {
@@ -43,6 +80,25 @@ export class UserSettings {
   @ApiProperty({ type: String, required: true })
   @Prop({ type: mongoose.Schema.Types.ObjectId, ref: "User", required: true })
   userId: string;
+
+  @ApiProperty({
+    type: [Object],
+    default: kDefaultFilters,
+    description: "Array of filters the user has set",
+  })
+  @Prop({
+    type: [{ type: Object }],
+    default: kDefaultFilters,
+  })
+  filters: FilterConfig[];
+
+  @ApiProperty({
+    type: [Object],
+    default: [],
+    description: "Array of conditions the user has set",
+  })
+  @Prop({ type: [{ type: Object }], default: [] })
+  conditions: ScientificCondition[];
 }
 
 export const UserSettingsSchema = SchemaFactory.createForClass(UserSettings);

src/users/users.controller.spec.ts

@@ -3,17 +3,43 @@
 import { CaslModule } from "src/casl/casl.module";
 import { UsersController } from "./users.controller";
 import { UsersService } from "./users.service";
+import { UpdateUserSettingsDto } from "./dto/update-user-settings.dto";
 
 class UsersServiceMock {
   findByIdUserIdentity(id: string) {
     return { id };
   }
+
+  async findByIdUserSettings(userId: string) {
+    return mockUserSettings;
+  }
+
+  async findOneAndUpdateUserSettings(
+    userId: string,
+    updateUserSettingsDto: UpdateUserSettingsDto,
+  ) {
+    return { ...updateUserSettingsDto, _id: userId };
+  }
 }
 
+const mockUserSettings = {
+  _id: "user1",
+  userId: "user1",
+  columns: [],
+  datasetCount: 25,
+  jobCount: 25,
+  filters: [
+    { type: "LocationFilterComponent", visible: true },
+    { type: "PidFilterComponent", visible: true },
+  ],
+  conditions: [{ field: "status", value: "active", operator: "equals" }],
+};
+
 class AuthServiceMock {}
 
 describe("UsersController", () => {
   let controller: UsersController;
+  let usersService: UsersService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -26,9 +52,58 @@
     }).compile();
 
     controller = module.get<UsersController>(UsersController);
+    usersService = module.get<UsersService>(UsersService);
+
+    // bypass authorization
+    jest
+      .spyOn(controller as UsersController, "checkUserAuthorization")
+      .mockImplementation(() => Promise.resolve());
   });
 
   it("should be defined", () => {
     expect(controller).toBeDefined();
   });
+
+  it("should return user settings with filters and conditions", async () => {
+    jest
+      .spyOn(usersService, "findByIdUserSettings")
+      .mockResolvedValue(mockUserSettings);
+
+    const userId = "user1";
+    const result = await controller.getSettings(
+      { user: { _id: userId } },
+      userId,
+    );
+
+    expect(result).toEqual(mockUserSettings);
+    expect(result.filters).toBeDefined();
+    expect(result.filters.length).toBeGreaterThan(0);
+    expect(result.conditions).toBeDefined();
+    expect(result.conditions.length).toBeGreaterThan(0);
+  });
+
+  it("should update user settings with filters and conditions", async () => {
+    const updatedSettings = {
+      ...mockUserSettings,
+      filters: [{ type: "PidFilterContainsComponent", visible: false }],
+      conditions: [{ field: "status", value: "inactive", operator: "equals" }],
+    };
+
+    jest
+      .spyOn(usersService, "findOneAndUpdateUserSettings")
+      .mockResolvedValue(updatedSettings);
+
+    const userId = "user-id";
+    const result = await controller.updateSettings(
+      { user: { _id: userId } },
+      userId,
+      updatedSettings,
+    );
+
+    expect(result).toEqual(updatedSettings);
+    expect(result.filters).toBeDefined();
+    expect(result.filters.length).toBe(1);
+    expect(result.conditions).toBeDefined();
+    expect(result.conditions.length).toBe(1);
+  });
 });

src/users/users.controller.ts

@@ -12,6 +12,7 @@
   Body,
   ForbiddenException,
   HttpCode,
+  CanActivate,
 } from "@nestjs/common";
 import {
   ApiBearerAuth,
@@ -31,7 +32,10 @@
 import { JWTUser } from "../auth/interfaces/jwt-user.interface";
 import { UserSettings } from "./schemas/user-settings.schema";
 import { CreateUserSettingsDto } from "./dto/create-user-settings.dto";
-import { PartialUpdateUserSettingsDto } from "./dto/update-user-settings.dto";
+import {
+  PartialUpdateUserSettingsDto,
+  UpdateUserSettingsDto,
+} from "./dto/update-user-settings.dto";
 import { User } from "./schemas/user.schema";
 import { CreateUserSettingsInterceptor } from "./interceptors/create-user-settings.interceptor";
 import { AuthService } from "src/auth/auth.service";
@@ -44,6 +48,8 @@
 import { AuthenticatedPoliciesGuard } from "../casl/guards/auth-check.guard";
 import { ReturnedUserDto } from "./dto/returned-user.dto";
 import { ReturnedAuthLoginDto } from "src/auth/dto/returnedLogin.dto";
+import { PoliciesGuard } from "src/casl/guards/policies.guard";
+import { DefaultUserSettingsInterceptor } from "./interceptors/default-user-settings.interceptor";
 
 @ApiBearerAuth()
 @ApiTags("users")
@@ -307,6 +313,42 @@
     return this.usersService.findOneAndDeleteUserSettings(id);
   }
 
+  @UseInterceptors(DefaultUserSettingsInterceptor)
+  @UseGuards(
+    class ByPassAuthenticatedPoliciesGuard
+      extends PoliciesGuard
+      implements CanActivate
+    {
+      async canActivate(): Promise<boolean> {
+        return Promise.resolve(true);
+      }
+    },
+  )
+  @Get("/settings/default")
+  async getDefaultSettings(): Promise<UserSettings> {
+    return Promise.resolve(new UserSettings());
+  }
+
+  @UseGuards(AuthenticatedPoliciesGuard)
+  @CheckPolicies((ability: AppAbility) =>
+    ability.can(Action.UserCreateAny, User),
+  )
+  @Post("/settings/default")
+  async postDefaultSettings(
+    @Req() request: Request,
+    @Body() createUserSettingsDto: CreateUserSettingsDto,
+  ): Promise<UserSettings> {
+    await this.checkUserAuthorization(
+      request,
+      [Action.UserCreateAny],
+      createUserSettingsDto.userId,
+    );
+    return this.usersService.createUserSettings(
+      "default",
+      createUserSettingsDto,
+    );
+  }
+
   @UseGuards(AuthenticatedPoliciesGuard)
   @CheckPolicies((ability: AppAbility) => {
     return (

test/Users.js

@@ -53,7 +53,7 @@ describe("2360: Users settings", () => {
     );
   });
 
-  it("0010: Update users settings with valid value should sucess ", async () => {
+  it("0010: Update users settings with valid value should success ", async () => {
     return request(appUrl)
       .put(`/api/v3/Users/${userIdUser1}/settings`)
       .set("Accept", "application/json")
@@ -64,6 +64,8 @@ describe("2360: Users settings", () => {
         res.body.should.have.property("userId", userIdUser1);
         res.body.should.have.property("datasetCount");
         res.body.should.have.property("jobCount");
+        res.body.should.have.property("filters");
+        res.body.should.have.property("conditions");
       });
   });
 });