@solidstarters/solid-core 1.2.0

package/src/controllers/action-metadata.controller.ts

@@ -0,0 +1,66 @@
+import { Controller, Post, Body, Param, UploadedFiles, UseInterceptors, Put, Get, Query, Delete } from '@nestjs/common';
+import { AnyFilesInterceptor } from "@nestjs/platform-express";
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { ActionMetadataService } from '../services/action-metadata.service';
+import { CreateActionMetadataDto } from '../dtos/create-action-metadata.dto';
+import { UpdateActionMetadataDto } from '../dtos/update-action-metadata.dto';
+
+@ApiTags('App')
+@Controller('action-metadata') //FIXME: Change this to the model plural name 
+export class ActionMetadataController {
+  constructor(private readonly service: ActionMetadataService) { }
+
+  @ApiBearerAuth("jwt")
+  @Post()
+  @UseInterceptors(AnyFilesInterceptor())
+  create(@Body() createDto: CreateActionMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.create(createDto, files);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post('/bulk')
+  @UseInterceptors(AnyFilesInterceptor())
+  insertMany(@Body() createDtos: CreateActionMetadataDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = []) {
+    return this.service.insertMany(createDtos, filesArray);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Put(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  update(@Param('id') id: number, @Body() updateDto: UpdateActionMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files);
+  }
+
+  @ApiBearerAuth("jwt")
+  @ApiQuery({ name: 'showSoftDeleted', required: false, type: Boolean })
+  @ApiQuery({ name: 'showOnlySoftDeleted', required: false, type: Boolean })
+  @ApiQuery({ name: 'limit', required: false, type: Number })
+  @ApiQuery({ name: 'offset', required: false, type: Number })
+  @ApiQuery({ name: 'fields', required: false, type: Array })
+  @ApiQuery({ name: 'sort', required: false, type: Array })
+  @ApiQuery({ name: 'groupBy', required: false, type: Array })
+  @ApiQuery({ name: 'populate', required: false, type: Array })
+  @ApiQuery({ name: 'populateMedia', required: false, type: Array })
+  @ApiQuery({ name: 'filters', required: false, type: Array })
+  @Get()
+  async findMany(@Query() query: any) {
+    return this.service.find(query);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Get(':id')
+  async findOne(@Param('id') id: string, @Query() query: any) {
+    return this.service.findOne(+id, query);
+  }
+
+  @Delete('/bulk')
+  async deleteMany(@Body() ids: number[]) {
+    return this.service.deleteMany(ids);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Delete(':id')
+  async delete(@Param('id') id: number) {
+    return this.service.delete(id);
+  }
+}

package/src/controllers/authentication.controller.ts

@@ -0,0 +1,100 @@
+import { Body, Controller, Get, HttpCode, HttpStatus, Logger, Post, Res, UseGuards } from '@nestjs/common';
+import { AuthenticationService } from '../services/authentication.service';
+import { SignInDto } from '../dtos/sign-in.dto';
+import { SignUpDto } from '../dtos/sign-up.dto';
+import { Response } from 'express';
+import { RefreshTokenDto } from '../dtos/refresh-token.dto';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { LocalAuthGuard } from '../passport-strategies/local.strategy';
+import { Public } from '../decorators/public.decorator';
+import { InitiateForgotPasswordDto } from '../dtos/initiate-forgot-password.dto';
+import { ConfirmForgotPasswordDto } from '../dtos/confirm-forgot-password.dto';
+import { ChangePasswordDto } from "../dtos/change-password.dto";
+import { ActiveUser } from "../decorators/active-user.decorator";
+import { ActiveUserData } from "../interfaces/active-user-data.interface";
+import { RegisterPrivateDto } from '../dtos/register-private.dto';
+
+
+// @Auth(AuthType.None)
+@Controller('iam')
+@ApiTags("Iam")
+export class AuthenticationController {
+    private readonly logger = new Logger(AuthenticationController.name);
+
+    constructor(private readonly authService: AuthenticationService) { }
+
+    @Public()
+    @Post('register')
+    signUp(@Body() signUpDto: SignUpDto) {
+        return this.authService.signUp(signUpDto);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Post('register-private')
+    signUpPrivate(@Body() signUpDto: SignUpDto, @ActiveUser() activeUser: ActiveUserData) {
+        return this.authService.signUp(signUpDto, activeUser);
+    }
+
+    @Public()
+    // @UseGuards(LocalAuthGuard)
+    @HttpCode(HttpStatus.OK) // by default @Post does 201, we wanted 200 - hence using @HttpCode(HttpStatus.OK)
+    @Post('authenticate')
+    async signIn(
+        @Res({ passthrough: true }) response: Response,
+        @Body() signInDto: SignInDto
+    ) {
+        // This means that we are passing the token back in plain text. 
+        // This is less secure. 
+        // console.log("signInDto in Signin Controller", signInDto);
+
+        return this.authService.signIn(signInDto);
+
+        // This means we are setting the token as a http only cookie.
+        // const accessToken = await this.authService.signIn(signInDto);
+        // response.cookie('accessToken', accessToken, {
+        //     secure: true,
+        //     httpOnly: true,
+        //     sameSite: true,
+        //   });
+    }
+
+    @Public()
+    @HttpCode(HttpStatus.OK) // changed since the default is 201
+    @Post('refresh-tokens')
+    refreshTokens(@Body() refreshTokenDto: RefreshTokenDto) {
+        return this.authService.refreshTokens(refreshTokenDto);
+    }
+
+    @Public()
+    @Post('initiate/forgot-password')
+    initiateForgotPassword(@Body() initiateForgotPasswordDto: InitiateForgotPasswordDto) {
+        return this.authService.initiateForgotPassword(initiateForgotPasswordDto);
+    }
+
+    @Public()
+    @Post('confirm/forgot-password')
+    confirmForgotPassword(@Body() confirmForgotPasswordDto: ConfirmForgotPasswordDto) {
+        return this.authService.confirmForgotPassword(confirmForgotPasswordDto);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Post('change-password')
+    changePassword(@Body() changePasswordDto: ChangePasswordDto, @ActiveUser() activeUser: ActiveUserData) {
+        return this.authService.changePassword(changePasswordDto, activeUser);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Get('me')
+    me(
+        @ActiveUser() activeUser: ActiveUserData
+    ) {
+        return this.authService.me(activeUser);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Post('logout')
+    @HttpCode(HttpStatus.OK)
+    async logout() {
+        return this.authService.logout();
+    }
+}

package/src/controllers/email-template.controller.ts

@@ -0,0 +1,150 @@
+import { Body, Controller, Delete, Get, Header, Param, Patch, Post, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
+import { Roles } from 'src/decorators/roles.decorator';
+import { EmailTemplateService } from '../services/email-template.service';
+import { CreateEmailTemplateDto } from '../dtos/create-email-template.dto';
+import { UpdateEmailTemplateDto } from '../dtos/update-email-template.dto';
+import { Public } from 'src/decorators/public.decorator';
+
+
+
+// TODO: esInterop not working somehow, defaulted to using the require syntax to import Mailgen. Figure a better way to do this. 
+// import { Mailgen } from 'mailgen';
+import Mailgen = require('mailgen');
+
+
+@Controller('email-templates')
+@ApiTags("Common")
+export class EmailTemplateController {
+  constructor(private readonly emailTemplateService: EmailTemplateService) { }
+
+  @ApiBearerAuth("jwt")
+  @Roles('Admin')
+  @Post()
+  create(@Body() dto: CreateEmailTemplateDto) {
+    return this.emailTemplateService.create(dto);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Roles('Admin')
+  @ApiQuery({ name: 'limit', required: false, type: Number })
+  @ApiQuery({ name: 'offset', required: false, type: Number })
+  @Get()
+  findAll(@Query() paginationQuery: PaginationQueryDto) {
+    return this.emailTemplateService.findAll(paginationQuery);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Roles('Admin')
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.emailTemplateService.findOne(+id);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() dto: UpdateEmailTemplateDto) {
+    return this.emailTemplateService.update(+id, dto);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.emailTemplateService.remove(+id);
+  }
+
+  // /api/email-templates/mailgen-template/otp-template
+  // @ApiBearerAuth("jwt")
+  // @Roles('Admin')
+  @Public()
+  @Get('mailgen-template/:templateType')
+  @Header('content-type', 'text/html')
+  generateMailgenTemplate(@Param('templateType') templateType: string) {
+    const appName = process.env.SOLID_APP_NAME;
+    const appUrl = process.env.SOLID_APP_WEBSITE_URL;
+
+    // Configure mailgen by setting a theme and your product info
+    var mailGenerator = new Mailgen({
+      theme: 'default',
+      product: {
+        // Appears in header & footer of e-mails
+        name: appName,
+        link: appUrl
+        // Optional product logo
+        // logo: 'https://mailgen.js/img/logo.png'
+      }
+    });
+
+    let email = null;
+    if (templateType === 'otp-on-register') {
+      email = {
+        body: {
+          name: 'John Appleseed',
+          intro: `Welcome to ${appName}! We\'re very excited to have you on board.`,
+          action: {
+            instructions: `To get started with ${appName}, please verify your account using the below verification code.`,
+            button: {
+              color: '#22BC66', // Optional action button color
+              text: `321455`,
+              link: null
+            }
+          },
+          outro: 'Need help, or have questions? Just reply to this email, we\'d love to help.'
+        }
+      };
+    }
+    if (templateType === 'otp-on-login') {
+      email = {
+        body: {
+          name: 'John Appleseed',
+          intro: `Welcome to ${appName}!`,
+          action: {
+            instructions: `Login to ${appName}, using the below verification code.`,
+            button: {
+              color: '#22BC66', // Optional action button color
+              text: `321455`,
+              link: null
+            }
+          },
+          outro: 'Need help, or have questions? Just reply to this email, we\'d love to help.'
+        }
+      };
+    }
+    if (templateType === 'forgot-password') {
+      email = {
+        body: {
+          name: 'John Appleseed',
+          intro: `Welcome to ${appName}!`,
+          action: {
+            instructions: `Click on the below link to reset your password. Please note that this link will expire in 10 minutes.`,
+            button: {
+              color: '#22BC66', // Optional action button color
+              text: `Reset Password`,
+              link: `https://example.com`
+            }
+          },
+          outro: 'Need help, or have questions? Just reply to this email, we\'d love to help.'
+        }
+      };
+    }
+
+    // Generate an HTML email with the provided contents
+    var emailBody = mailGenerator.generate(email);
+
+    // Generate the plaintext version of the e-mail (for clients that do not support HTML)
+    // var emailText = mailGenerator.generatePlaintext(email);
+
+    // Optionally, preview the generated HTML e-mail by writing it to a local file
+    // require('fs').writeFileSync('preview.html', emailBody, 'utf8');
+
+    // `emailBody` now contains the HTML body,
+    // and `emailText` contains the textual version.
+    //
+    // It's up to you to send the e-mail.
+    // Check out nodemailer to accomplish this:
+    // https://nodemailer.com/
+    return emailBody;
+  }
+
+}

package/src/controllers/field-metadata.controller.ts

@@ -0,0 +1,72 @@
+import { Body, Controller, Delete, Get, Param, ParseIntPipe, Post, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
+import { CreateFieldMetadataDto } from '../dtos/create-field-metadata.dto';
+import { FieldMetadataService } from '../services/field-metadata.service';
+import { Public } from 'src/decorators/public.decorator';
+import { BasicFilterDto } from '../dtos/basic-filters.dto';
+import { SelectionDynamicQueryDto } from '../dtos/selection-dynamic-query.dto';
+
+@Controller('field-metadata')
+@ApiTags("App Builder")
+export class FieldMetadataController {
+
+    constructor(
+        private readonly fieldMetadataService: FieldMetadataService
+    ) { }
+
+    @ApiBearerAuth("jwt")
+    @ApiQuery({ name: 'limit', required: false, type: Number })
+    @ApiQuery({ name: 'offset', required: false, type: Number })
+    @ApiQuery({ name: 'fields', required: false, type: Array })
+    @ApiQuery({ name: 'sort', required: false, type: Array })
+    @ApiQuery({ name: 'groupBy', required: false, type: Array })
+    @ApiQuery({ name: 'populate', required: false, type: Array })
+    @ApiQuery({ name: 'populateMedia', required: false, type: Array })
+    @ApiQuery({ name: 'filters', required: false, type: Array })
+    @Get()
+    async findMany(
+        @Query() basicFilterDto: BasicFilterDto
+    ) {
+        return this.fieldMetadataService.findMany(basicFilterDto);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Get('/default')
+    async findFieldDefaultMetaData() {
+        return this.fieldMetadataService.findFieldDefaultMetaData();
+    }
+
+    @ApiBearerAuth("jwt")
+    @Get('/selection-dynamic-values')
+    async getSelectionDynamicValues(@Query() query: SelectionDynamicQueryDto) {
+        return this.fieldMetadataService.getSelectionDynamicValues(query);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Get('/selection-dynamic-value')
+    async getSelectionDynamicValue(@Query() query: SelectionDynamicQueryDto) {
+        return this.fieldMetadataService.getSelectionDynamicValue(query);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Get(':id')
+    findOne(@Param('id', ParseIntPipe) id: number, @Query() query: any) {
+        return this.fieldMetadataService.findOne(id, query);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Post()
+    create(@Body() createDtos: CreateFieldMetadataDto[]) {
+        return Promise.all(createDtos.map(dto => this.fieldMetadataService.create(dto)));
+    }
+
+    @ApiBearerAuth("jwt")
+    @Delete(':id')
+    remove(@Param('id') id: number) {
+        return this.fieldMetadataService.remove(id);
+    }
+
+
+
+}

package/src/controllers/google-authentication.controller.ts

@@ -0,0 +1,78 @@
+import { Controller, Get, Inject, Query, Req, Res, UseGuards } from '@nestjs/common';
+import { AuthenticationService } from '../services/authentication.service';
+import { Auth } from '../decorators/auth.decorator';
+import { AuthType } from '../enums/auth-type.enum';
+import { ApiQuery, ApiTags } from '@nestjs/swagger';
+import { GoogleOauthGuard } from '../passport-strategies/google-oauth.strategy';
+import { Request, Response } from 'express';
+import { ConfigType } from '@nestjs/config';
+import { UserService } from '../services/user.service';
+import { Public } from '../decorators/public.decorator';
+import { iamConfig } from '../config/iam.config';
+
+
+@Auth(AuthType.None)
+@Controller('iam/google')
+@ApiTags("Iam")
+export class GoogleAuthenticationController {
+    constructor(
+        @Inject(iamConfig.KEY) private iamConfiguration: ConfigType<typeof iamConfig>,
+        private readonly userService: UserService,
+        private readonly authService: AuthenticationService,
+    ) { }
+
+    @Public()
+    @UseGuards(GoogleOauthGuard)
+    @Get('connect')
+    async connect() { }
+
+    @Public()
+    @Get('connect/callback')
+    @UseGuards(GoogleOauthGuard)
+    googleAuthCallback(@Req() req: Request, @Res() res: Response) {
+        const user = req.user;
+
+        // console.log(`Found user: ${JSON.stringify(user)}`);
+        // const token = await this.authService.signIn(req.user);
+        //   res.cookie('access_token', token, {
+        //     maxAge: 2592000000,
+        //     sameSite: true,
+        //     secure: false,
+        //   });
+        // return req.user;
+        // return res;
+
+        return res.redirect(`${this.iamConfiguration.googleOauth.redirectURL}?accessCode=${user['accessCode']}`);
+    }
+
+    /**
+     * This is just a dummy endpoint where we are passing in the accessCode, this will be configured in the .env as an environment variable and 
+     * will be passed the accessCode, using the accessCode the UI code on this page will mostly invoke the /iam/google/auth endpoint which will finally generate the JWT token.
+     * 
+     * @param accessCode 
+     * @returns 
+     */
+    @Public()
+    @Get('dummy-redirect')
+    async dummyGoogleAuthRedirect(@Query('accessCode') accessCode) {
+        const user = await this.userService.findOneByAccessCode(accessCode);
+
+        delete user['password'];
+
+        return user;
+    }
+
+    /**
+     * This is just a dummy endpoint where we are passing in the accessCode, this will be configured in the .env as an environment variable and 
+     * will be passed the accessCode, using the accessCode the UI code on this page will mostly invoke the /iam/google/auth endpoint which will finally generate the JWT token.
+     * 
+     * @param accessCode 
+     * @returns 
+     */
+    @Public()
+    @Get('authenticate')
+    @ApiQuery({ name: 'accessCode', required: true, type: String })
+    async googleAuth(@Query('accessCode') accessCode) {
+        return this.authService.signInUsingGoogle(accessCode);
+    }
+}

package/src/controllers/media-storage-provider-metadata.controller.ts

@@ -0,0 +1,64 @@
+import { Body, Controller, Delete, Get, Logger, Param, ParseIntPipe, Post, Put, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
+import { CreateMediaStorageProviderMetadataDto } from '../dtos/create-media-storage-provider-metadata.dto';
+import { MediaStorageProviderMetadataService } from '../services/media-storage-provider-metadata.service';
+import { BasicFilterDto } from '../dtos/basic-filters.dto';
+import { UpdateMediaStorageProviderMetadataDto } from '../dtos/update-media-storage-provider.dto';
+
+@Controller('media-storage-provider-metadata')
+@ApiTags("App Builder")
+export class MediaStorageProviderMetadataController {
+    private logger = new Logger(MediaStorageProviderMetadataController.name);
+
+    constructor(
+        private readonly mediaStorageProviderService: MediaStorageProviderMetadataService
+    ) { }
+
+
+    @ApiBearerAuth("jwt")
+    @ApiQuery({ name: 'limit', required: false, type: Number })
+    @ApiQuery({ name: 'offset', required: false, type: Number })
+    @ApiQuery({ name: 'fields', required: false, type: Array })
+    @ApiQuery({ name: 'sort', required: false, type: Array })
+    @ApiQuery({ name: 'groupBy', required: false, type: Array })
+    @ApiQuery({ name: 'populate', required: false, type: Array })
+    @ApiQuery({ name: 'populateMedia', required: false, type: Array })
+    @ApiQuery({ name: 'filters', required: false, type: Array })
+    @Get()
+    async findMany(
+        @Query() basicFilterDto: BasicFilterDto
+    ) {
+        return this.mediaStorageProviderService.findMany(basicFilterDto);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Get(':id')
+    findOne(@Param('id', ParseIntPipe) id: number) {
+        return this.mediaStorageProviderService.findOne(id);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Post()
+    create(@Body() createDto: CreateMediaStorageProviderMetadataDto) {
+        // this.logger.log(`Creating a new model: ${JSON.stringify(createDto)}`);
+        return this.mediaStorageProviderService.create(createDto);
+    }
+
+    @Put(':id')
+    update(@Param('id') id: number, @Body() updateMediaStorageProviderMetadataDto: UpdateMediaStorageProviderMetadataDto) {
+        return this.mediaStorageProviderService.update(id, updateMediaStorageProviderMetadataDto);
+    }
+    @ApiBearerAuth("jwt")
+    @Delete('/bulk')
+    async deleteMany(@Body() ids: number[]) {
+        return this.mediaStorageProviderService.deleteMany(ids);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Delete(':id')
+    remove(@Param('id') id: number) {
+        return this.mediaStorageProviderService.remove(id);
+    }
+
+}

package/src/controllers/media.controller.ts

@@ -0,0 +1,75 @@
+import { Body, Controller, Delete, Get, Logger, Param, ParseIntPipe, Post, Query, UploadedFile, UploadedFiles, UseInterceptors } from '@nestjs/common';
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
+import { MediaService } from '../services/media.service';
+import { BasicFilterDto } from '../dtos/basic-filters.dto';
+import { CreateMediaDto } from '../dtos/create-media.dto';
+import { Public } from 'src/decorators/public.decorator';
+import { AnyFilesInterceptor } from '@nestjs/platform-express';
+
+@Controller('media')
+@ApiTags("App Builder")
+export class MediaController {
+    private logger = new Logger(MediaController.name);
+
+    constructor(
+        private readonly mediaService: MediaService
+    ) { }
+
+    @ApiBearerAuth("jwt")
+    @ApiQuery({ name: 'limit', required: false, type: Number })
+    @ApiQuery({ name: 'offset', required: false, type: Number })
+    @ApiQuery({ name: 'fields', required: false, type: Array })
+    @ApiQuery({ name: 'sort', required: false, type: Array })
+    @ApiQuery({ name: 'groupBy', required: false, type: Array })
+    @ApiQuery({ name: 'populate', required: false, type: Array })
+    @ApiQuery({ name: 'populateMedia', required: false, type: Array })
+    @ApiQuery({ name: 'filters', required: false, type: Array })
+    @Get()
+    async findMany(
+        @Query() basicFilterDto: BasicFilterDto
+    ) {
+        return this.mediaService.findMany(basicFilterDto);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Get(':id')
+    findOne(@Param('id', ParseIntPipe) id: number) {
+        return this.mediaService.findOne(id);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Post()
+    create(@Body() createDto: CreateMediaDto) {
+        // this.logger.log(`Creating a new model: ${JSON.stringify(createDto)}`);
+        return this.mediaService.create(createDto);
+    }
+
+    @Public()
+    @ApiBearerAuth("jwt")
+    @Post('/upload')
+    @UseInterceptors(AnyFilesInterceptor())
+    upload(@UploadedFiles() files: Array<Express.Multer.File>, @Body() createDto: CreateMediaDto, ) {
+        // this.logger.log(`Creating a new model: ${JSON.stringify(createDto)}`);
+        return this.mediaService.upload(createDto, files);
+    }
+
+
+
+    // @Patch(':id')
+    // update(@Param('id') id: number, @Body() updateCountryDto: UpdateCountryDto) {
+    //     return this.countriesService.update(id, updateCountryDto);
+    // }
+    @ApiBearerAuth("jwt")
+    @Delete('/bulk')
+    async deleteMany(@Body() ids: number[]) {
+      return this.mediaService.deleteMany(ids);
+    }
+
+    @ApiBearerAuth("jwt")
+    @Delete(':id')
+    remove(@Param('id') id: number) {
+        return this.mediaService.remove(id);
+    }
+
+}