Add reef admin relationships

packages/api/.eslintrc

@@ -52,6 +52,12 @@
           }
         ]
       }
+    },
+    {
+      "files": ["src/**/*.entity.{ts,js}"],
+      "rules": {
+        "import/no-cycle": "off"
+      }
     }
   ]
 }

packages/api/migration/1599586648784-ReefAdminManyToMany.ts

@@ -0,0 +1,76 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ReefAdminManyToMany1599586648784 implements MigrationInterface {
+  name = 'ReefAdminManyToMany1599586648784';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "reef" DROP CONSTRAINT "FK_dc56bfd6bfcd1f221ec83885294"`,
+    );
+    await queryRunner.query(
+      `
+      CREATE TABLE "users_administered_reefs_reef" (
+        "reef_id" integer NOT NULL,
+        "users_id" integer NOT NULL,
+        CONSTRAINT "PK_21f162e26e837a19d1e1accd1cd" PRIMARY KEY ("reef_id", "users_id")
+      )
+      `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_088a629ef23eb9eba6ac857ed6" ON "users_administered_reefs_reef" ("reef_id") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_da52b9542bf7df43f4840ae439" ON "users_administered_reefs_reef" ("users_id") `,
+    );
+    await queryRunner.query(`ALTER TABLE "reef" DROP COLUMN "admin_id"`);
+    await queryRunner.query(
+      `
+      ALTER TABLE "users_administered_reefs_reef" ADD CONSTRAINT "FK_088a629ef23eb9eba6ac857ed62"
+      FOREIGN KEY ("reef_id") REFERENCES "reef"("id") ON DELETE CASCADE ON UPDATE NO ACTION
+      `,
+    );
+    await queryRunner.query(
+      `
+      ALTER TABLE "users_administered_reefs_reef" ADD CONSTRAINT "FK_da52b9542bf7df43f4840ae4394"
+      FOREIGN KEY ("users_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE NO ACTION
+      `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "reef_application" DROP CONSTRAINT "FK_77d33d9b9602120cd1529312e77"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "reef_application" DROP CONSTRAINT "UQ_77d33d9b9602120cd1529312e77"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "reef_application" ADD CONSTRAINT "FK_77d33d9b9602120cd1529312e77" FOREIGN KEY ("reef_id") REFERENCES "reef"("id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "users_administered_reefs_reef" DROP CONSTRAINT "FK_da52b9542bf7df43f4840ae4394"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "users_administered_reefs_reef" DROP CONSTRAINT "FK_088a629ef23eb9eba6ac857ed62"`,
+    );
+    await queryRunner.query(`ALTER TABLE "reef" ADD "admin_id" integer`);
+    await queryRunner.query(`DROP INDEX "IDX_da52b9542bf7df43f4840ae439"`);
+    await queryRunner.query(`DROP INDEX "IDX_088a629ef23eb9eba6ac857ed6"`);
+    await queryRunner.query(`DROP TABLE "users_administered_reefs_reef"`);
+    await queryRunner.query(
+      `
+      ALTER TABLE "reef" ADD CONSTRAINT "FK_dc56bfd6bfcd1f221ec83885294"
+      FOREIGN KEY ("admin_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE NO ACTION
+      `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "reef_application" DROP CONSTRAINT "FK_77d33d9b9602120cd1529312e77"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "reef_application" ADD CONSTRAINT "UQ_77d33d9b9602120cd1529312e77" UNIQUE ("reef_id")`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "reef_application" ADD CONSTRAINT "FK_77d33d9b9602120cd1529312e77" FOREIGN KEY ("reef_id") REFERENCES "reef"("id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+}

packages/api/src/auth/auth.decorator.ts

@@ -4,9 +4,6 @@ import { FirebaseAuthGuard } from './firebase-auth.guard';
 import { LevelsGuard } from './levels.guard';
 
 export const Auth = (...levels: AdminLevel[]) => {
-  if (!levels) {
-    return UseGuards(FirebaseAuthGuard);
-  }
   return applyDecorators(
     SetMetadata('levels', levels),
     UseGuards(FirebaseAuthGuard, LevelsGuard),

packages/api/src/auth/firebase-auth.guard.ts

@@ -1,5 +1,24 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, ExecutionContext } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
+import { Reflector } from '@nestjs/core';
+import { of } from 'rxjs';
 
 @Injectable()
-export class FirebaseAuthGuard extends AuthGuard('custom') {}
+export class FirebaseAuthGuard extends AuthGuard('custom') {
+  constructor(private reflector: Reflector) {
+    super();
+  }
+
+  canActivate(context: ExecutionContext) {
+    const isPublic = this.reflector.get<boolean>(
+      'isPublic',
+      context.getHandler(),
+    );
+
+    if (isPublic) {
+      return of(true);
+    }
+
+    return super.canActivate(context);
+  }
+}

packages/api/src/auth/is-reef-admin.guard.ts

@@ -0,0 +1,48 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Reflector } from '@nestjs/core';
+import { Repository } from 'typeorm';
+import { User, AdminLevel } from '../users/users.entity';
+import { Reef } from '../reefs/reefs.entity';
+
+export class IsReefAdminGuard implements CanActivate {
+  constructor(
+    @InjectRepository(Reef)
+    private reefRepository: Repository<Reef>,
+
+    private reflector: Reflector,
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const isPublic = this.reflector.get<boolean>(
+      'isPublic',
+      context.getHandler(),
+    );
+
+    if (isPublic) {
+      return true;
+    }
+
+    const request = context.switchToHttp().getRequest();
+    const { user }: { user: User } = request;
+    const reefId = parseInt(request.params.reef_id, 10);
+
+    if (user.adminLevel === AdminLevel.SuperAdmin) {
+      return true;
+    }
+
+    if (!Number.isNaN(reefId) && user.adminLevel === AdminLevel.ReefManager) {
+      const isReefAdmin = await this.reefRepository
+        .createQueryBuilder('reef')
+        .innerJoin('reef.admins', 'admins', 'admins.id = :userId', {
+          userId: user.id,
+        })
+        .andWhere('reef.id = :reefId', { reefId })
+        .getOne();
+
+      return !!isReefAdmin;
+    }
+
+    return false;
+  }
+}

packages/api/src/auth/levels.guard.ts

@@ -1,20 +1,28 @@
 import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import { AdminLevel } from '../users/users.entity';
+import { AuthRequest } from './auth.types';
 
 @Injectable()
 export class LevelsGuard implements CanActivate {
   constructor(private reflector: Reflector) {}
 
   async canActivate(context: ExecutionContext): Promise<boolean> {
+    const isPublic = this.reflector.get<boolean>(
+      'isPublic',
+      context.getHandler(),
+    );
+    if (isPublic) {
+      return true;
+    }
     const levels = this.reflector.get<AdminLevel[]>(
       'levels',
       context.getHandler(),
     );
     if (!levels || !levels.length) {
       return true;
     }
-    const request = context.switchToHttp().getRequest();
+    const request = context.switchToHttp().getRequest<AuthRequest>();
     const { user } = request;
     const hasAccess = levels.findIndex((l) => l === user.adminLevel) !== -1;
     return hasAccess;

packages/api/src/auth/override-level-access.decorator.ts

@@ -0,0 +1,6 @@
+import { applyDecorators, SetMetadata } from '@nestjs/common';
+import { AdminLevel } from '../users/users.entity';
+
+export const OverrideLevelAccess = (...levels: AdminLevel[]) => {
+  return applyDecorators(SetMetadata('levels', levels));
+};

packages/api/src/auth/public.decorator.ts

@@ -0,0 +1,5 @@
+import { applyDecorators, SetMetadata } from '@nestjs/common';
+
+export const Public = () => {
+  return applyDecorators(SetMetadata('isPublic', true));
+};

packages/api/src/reef-applications/reef-applications.entity.ts

@@ -2,11 +2,9 @@ import {
   Entity,
   PrimaryGeneratedColumn,
   Column,
-  OneToOne,
   ManyToOne,
   CreateDateColumn,
   UpdateDateColumn,
-  JoinColumn,
 } from 'typeorm';
 import { Exclude, Expose } from 'class-transformer';
 import { Reef } from '../reefs/reefs.entity';
@@ -41,8 +39,7 @@ export class ReefApplication {
   @UpdateDateColumn()
   updatedAt: Date;
 
-  @OneToOne(() => Reef, { onDelete: 'CASCADE' })
-  @JoinColumn()
+  @ManyToOne(() => Reef, { onDelete: 'CASCADE' })
   reef: Reef;
 
   @ManyToOne(() => User, { onDelete: 'CASCADE' })

packages/api/src/reef-pois/reef-pois.controller.ts

@@ -16,32 +16,34 @@ import { FilterReefPoiDto } from './dto/filter-reef-poi.dto';
 import { UpdateReefPoiDto } from './dto/update-reef-poi.dto';
 import { AdminLevel } from '../users/users.entity';
 import { Auth } from '../auth/auth.decorator';
+import { Public } from '../auth/public.decorator';
 
+@Auth(AdminLevel.ReefManager, AdminLevel.SuperAdmin)
 @Controller('pois')
 export class ReefPoisController {
   constructor(private poisService: ReefPoisService) {}
 
-  @Auth(AdminLevel.ReefManager, AdminLevel.SuperAdmin)
   @Post()
   create(
     @Body() createReefPoiDto: CreateReefPoiDto,
   ): Promise<ReefPointOfInterest> {
     return this.poisService.create(createReefPoiDto);
   }
 
+  @Public()
   @Get()
   find(
     @Query() filterReefPoiDto: FilterReefPoiDto,
   ): Promise<ReefPointOfInterest[]> {
     return this.poisService.find(filterReefPoiDto);
   }
 
+  @Public()
   @Get(':id')
   findOne(@Param('id', ParseIntPipe) id: number): Promise<ReefPointOfInterest> {
     return this.poisService.findOne(id);
   }
 
-  @Auth(AdminLevel.ReefManager, AdminLevel.SuperAdmin)
   @Put(':id')
   update(
     @Param('id', ParseIntPipe) id: number,
@@ -50,7 +52,6 @@ export class ReefPoisController {
     return this.poisService.update(id, updateReefPoiDto);
   }
 
-  @Auth(AdminLevel.ReefManager, AdminLevel.SuperAdmin)
   @Delete(':id')
   delete(@Param('id', ParseIntPipe) id: number): Promise<void> {
     return this.poisService.delete(id);

packages/api/src/reef-pois/reef-pois.entity.ts

@@ -7,9 +7,7 @@ import {
   UpdateDateColumn,
   OneToMany,
 } from 'typeorm';
-// eslint-disable-next-line import/no-cycle
 import { Reef } from '../reefs/reefs.entity';
-// eslint-disable-next-line import/no-cycle
 import { SurveyMedia } from '../surveys/survey-media.entity';
 
 @Entity()

packages/api/src/reefs/daily-data.entity.ts

@@ -6,7 +6,6 @@ import {
   CreateDateColumn,
   UpdateDateColumn,
 } from 'typeorm';
-// eslint-disable-next-line import/no-cycle
 import { Reef } from './reefs.entity';
 
 @Entity()

packages/api/src/reefs/reefs.controller.ts

@@ -14,48 +14,39 @@ import { Reef } from './reefs.entity';
 import { CreateReefDto } from './dto/create-reef.dto';
 import { FilterReefDto } from './dto/filter-reef.dto';
 import { UpdateReefDto } from './dto/update-reef.dto';
-import surveys from '../../mock_response/survey_data.json';
 import { AdminLevel } from '../users/users.entity';
 import { Auth } from '../auth/auth.decorator';
+import { Public } from '../auth/public.decorator';
 
+@Auth(AdminLevel.ReefManager, AdminLevel.SuperAdmin)
 @Controller('reefs')
 export class ReefsController {
   constructor(private reefsService: ReefsService) {}
 
-  @Auth(AdminLevel.ReefManager, AdminLevel.SuperAdmin)
   @Post()
   create(@Body() createReefDto: CreateReefDto): Promise<Reef> {
     return this.reefsService.create(createReefDto);
   }
 
+  @Public()
   @Get()
   find(@Query() filterReefDto: FilterReefDto): Promise<Reef[]> {
     return this.reefsService.find(filterReefDto);
   }
 
+  @Public()
   @Get(':id')
   findOne(@Param('id', ParseIntPipe) id: number): Promise<Reef> {
     return this.reefsService.findOne(id);
   }
 
+  @Public()
   @Get(':id/daily_data')
   // eslint-disable-next-line no-unused-vars
   findDailyData(@Param('id') id: number) {
     return this.reefsService.findDailyData(id);
   }
 
-  @Get(':id/surveys/:poi')
-  findSurveys(@Param('id') id: string, @Param('poi') poi: string) {
-    return surveys.map((survey) => ({
-      ...survey,
-      images: survey.images.filter(
-        (image) => image.poi_label_id === parseInt(poi, 10),
-      ),
-    }));
-    // return this.reefRepository.findOneReef(id);
-  }
-
-  @Auth(AdminLevel.ReefManager, AdminLevel.SuperAdmin)
   @Put(':id')
   update(
     @Param('id', ParseIntPipe) id: number,
@@ -64,7 +55,6 @@ export class ReefsController {
     return this.reefsService.update(id, updateReefDto);
   }
 
-  @Auth(AdminLevel.ReefManager, AdminLevel.SuperAdmin)
   @Delete(':id')
   delete(@Param('id', ParseIntPipe) id: number): Promise<void> {
     return this.reefsService.delete(id);