modifications

src/app.module.ts

@@ -1,7 +1,6 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { typeOrmConfig } from './config/typeorm.config';
-
 import { AuthModule } from './auth/auth.module';
 import { FileUploadModule } from './file-upload/file-upload.module';
 import { ScheduleModule } from '@nestjs/schedule';
@@ -20,9 +19,6 @@ import { FileFormatLovModule } from './tables/file-format-lov/file-format-lov.mo
 import { CoversMasterModule } from './tables/covers-master/covers-master.module';
 
 
-
-
-
 @Module({
   imports: [
     ScheduleModule.forRoot(),

src/auth/auth.service.ts

@@ -61,7 +61,7 @@ export class AuthService {
         }
         if(user){
            // authCredentialsDto.secuLevel = user.secuLevel
-            return {username:user.userName ,secuLevel:user.secuLevel}
+            return {username:user.userName ,secuLevel:user.secuLevel , userId:user.userId , mobile:user.mobileNumber , email:user.email}
         }
        
 

src/dto/cover-master.dto.ts

@@ -0,0 +1,10 @@
+export class CoverMasterDto{
+
+    tenderId:number;
+
+    coverType:string;
+
+    Description:string;
+
+    fileFormat:string
+}

src/dto/tender-master.dto.ts

@@ -55,6 +55,6 @@ export class TenderDetailDto{
     tenderType:              number;
     tenderCategory:          number;
     formOfContract:          number;
-    emd_fee_type:            string;
+   emdFeeType:            string;
     activeYn:                string;
 }

src/file-upload/file-upload.controller.ts

@@ -1,14 +1,15 @@
-import { BadRequestException, Controller, Get, Param, Post, Req, Res, UploadedFile, UseGuards, UseInterceptors } from '@nestjs/common';
+import { BadRequestException, Controller, Delete, Get, NotFoundException, Param, Post, Req, Res, UploadedFile, UseGuards, UseInterceptors } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
 import { FileInterceptor } from '@nestjs/platform-express';
 import { existsSync, mkdirSync } from 'fs';
 import { diskStorage } from 'multer';
-import { extname } from 'path';
+
 import { GetUser } from 'src/auth/dto/get-user.decorator';
 import { FileUploadService } from './file-upload.service';
 import * as fs from 'fs';
 import * as archiver from 'archiver';
 import * as path from 'path';
+import { join, extname } from 'path';
 
 export function createFolders(filePath: string) {
 
@@ -33,20 +34,23 @@ export function createFolders(filePath: string) {
 
 
 @Controller('file-upload')
-
 export class FileUploadController {
     constructor(
         private iservice: FileUploadService
     ) {
     }
 
-    @Post('user-documents/:id')
+    @UseGuards(AuthGuard())
+    @Post('user-documents/:id/:userId')
     @UseInterceptors(FileInterceptor('file', {
         storage: diskStorage({
             destination: (req, res, cb) => {
-                const filePath: string = './uploads/userDocuments/'+req.params.id;
+                const parentFolder: string = './uploads/userDocuments/' + req.params.id;
-                createFolders(filePath);
+                createFolders(parentFolder);
-                return cb(null, filePath);
+                const childFolder: string = parentFolder + '/' + req.params.userId;
+                createFolders(childFolder);
+
+                return cb(null, childFolder);
             },
             filename: (req, file, cb) => {
                 console.log('===here===file upload==');
@@ -58,16 +62,18 @@ export class FileUploadController {
     userDoc(@UploadedFile() file) {
         return { fileName: file.filename, filePath: file.path };
     }
-   
+
-    
+
+
+    @UseGuards(AuthGuard())
     @Post('Bank-documents/:id')
     @UseInterceptors(FileInterceptor('file', {
         storage: diskStorage({
             // destination: './uploads/cars',
             destination: (req, res, cb) => {
-                // console.log(req);
+                console.log(req);
-                
+
-                const filePath: string = './uploads/BankDocuments/'+req.params.id;
+                const filePath: string = './uploads/BankDocuments/' + req.params.id;
                 createFolders(filePath);
                 return cb(null, filePath);
             },
@@ -87,15 +93,15 @@ export class FileUploadController {
         return { fileName: file.filename, filePath: file.path, fileSizeKB };
     }
 
-    
+    @UseGuards(AuthGuard())
     @Post('drawings/:id')
     @UseInterceptors(FileInterceptor('file', {
         storage: diskStorage({
             // destination: './uploads/cars',
             destination: (req, res, cb) => {
                 // console.log(req);
-                
+
-                const filePath: string = './uploads/Drawings/'+req.params.id;
+                const filePath: string = './uploads/Drawings/' + req.params.id;
                 createFolders(filePath);
                 return cb(null, filePath);
             },
@@ -115,10 +121,106 @@ export class FileUploadController {
         return { fileName: file.filename, filePath: file.path, fileSizeKB };
     }
 
+    @UseGuards(AuthGuard())
+    @Delete('R-drawing/:id/:filename')
+  async deleteDrawing(
+    @Param('filename') filename : string,
+    @Param('id')  id:string): Promise<any> {
+    const filePath = './uploads/Drawings/'+id+'/'+ filename;
+        console.log("filepath===",filePath);
+        
+    try {
+      await fs.promises.unlink(filePath);
+      return { message: 'File deleted successfully.' };
+    } catch (err) {
+      throw new NotFoundException('File not found.');
+    }
+  }
 
 
+  @UseGuards(AuthGuard())
+    @Delete('R-userDoc/:id/:userId/:filename')
+  async deleteUserDoc(
+    @Param('userId') userId:string,
+    @Param('filename') filename : string,
+    @Param('id')  id:string): Promise<any> {
+    const filePath = './uploads/userDocuments/'+id+'/'+userId +'/'+ filename;
+        console.log("filepath===",filePath);
+        
+    try {
+      await fs.promises.unlink(filePath);
+      return { message: 'File deleted successfully.' };
+    } catch (err) {
+      throw new NotFoundException('File not found.');
+    }
+  }
 
+  @UseGuards(AuthGuard())
+  @Delete('R-notice/:id/:filename')
+async deleteNotice(
+  @Param('filename') filename : string,
+  @Param('id')  id:string): Promise<any> {
+  const filePath = './uploads/Notice/'+id +'/'+ filename;
+      console.log("filepath===",filePath);
+      
+  try {
+    await fs.promises.unlink(filePath);
+    return { message: 'File deleted successfully.' };
+  } catch (err) {
+    throw new NotFoundException('File not found.');
+  }
+}
 
+
+    @UseGuards(AuthGuard())
+    @Post('notice/:id')
+    @UseInterceptors(FileInterceptor('file', {
+        storage: diskStorage({
+            // destination: './uploads/cars',
+            destination: (req, res, cb) => {
+                // console.log(req);
+
+                const filePath: string = './uploads/Notice/' + req.params.id;
+                createFolders(filePath);
+                return cb(null, filePath);
+            },
+            filename: (req, file, cb) => {
+                console.log('===here===file upload==');
+                const randomName = Array(32).fill(null).map(() => (Math.round(Math.random() * 16)).toString(16)).join('');
+                return cb(null, `${randomName}${extname(file.originalname)}`);
+            }
+        })
+    }))
+
+    notice(@UploadedFile() file) {
+        if (!file) {
+            return { error: 'No file uploaded.' };
+        }
+        //To return the size of the document in kb
+        const fileSizeKB = Math.ceil(file.size / 1024);
+        return { fileName: file.filename, filePath: file.path, fileSizeKB };
+    }
+
+
+    @Get('notice/:id/:imgpath')
+    getNotice(
+        @Param('imgpath') image: string,
+        @Param('id') id: string,
+        @Res() res,
+        @Req() req,
+    ) {
+        return res.sendFile(image, { root: './uploads/Notice/' + id }, function (err) {
+            if (err) {
+                console.log(err.status);
+                res.status(err.status).end();
+            }
+        })
+    }
+
+
+
+
+    @UseGuards(AuthGuard())
     @Get('Bank-Documents/:id/:imgpath')
     getBankDocuments(
         @Param('imgpath') image: string,
@@ -127,7 +229,7 @@ export class FileUploadController {
         @Req() req,
 
     ) {
-        return res.sendFile(image, { root: './uploads/BankDocuments/'+id}, function (err) {
+        return res.sendFile(image, { root: './uploads/BankDocuments/' + id }, function (err) {
             if (err) {
                 console.log(err.status);
                 res.status(err.status).end();
@@ -135,15 +237,17 @@ export class FileUploadController {
         })
     }
 
-    @Get('user-Documents/:id/:imgpath')
+    @UseGuards(AuthGuard())
+    @Get('user-Documents/:id/:userId/:imgpath')
     getUserDocuments(
         @Param('imgpath') image: string,
+        @Param('userId') userId: string,
         @Param('id') id: string,
         @Res() res,
         @Req() req,
 
     ) {
-        return res.sendFile(image, { root: './uploads/userDocuments/'+id}, function (err) {
+        return res.sendFile(image, { root: './uploads/userDocuments/' + id + '/' + userId }, function (err) {
             if (err) {
                 console.log(err.status);
                 res.status(err.status).end();
@@ -151,119 +255,178 @@ export class FileUploadController {
         })
     }
 
-    
 
+    @UseGuards(AuthGuard())
     @Get('Bank-Documents-Arc/:id')
     async getBankDocumentsAsZip(
         @Param('id') id: string,
         @Res() res,
         @Req() req,
-      ) {
+    ) {
         const folderPath = path.join('./uploads/BankDocuments', id);
         if (!fs.existsSync(folderPath)) {
-          res.status(404).send({ error: 'File not found' });
+            res.status(404).send({ error: 'File not found' });
-          return;
+            return;
-        }  
+        }
 
         //Uncomment when we want tender id as the zip file name
         //const zipFileName = id + '.zip';
         const zipFileName = 'tenderDocuments.zip';
         const zipPath = path.join('./uploads/BankDocuments', zipFileName);
-      
+
         // Create a new archive
         const archive = archiver('zip', {
-          zlib: { level: 9 } // Set compression level (optional)
+            zlib: { level: 9 } // Set compression level (optional)
         });
-      
+
         // Create a write stream to the zip file
         const output = fs.createWriteStream(zipPath);
-      
+
         // Pipe the archive to the write stream
         archive.pipe(output);
-      
+
         // Add the entire folder to the archive
         archive.directory(folderPath, id);
-      
+
         // Finalize the archive
         await archive.finalize();
-      
+
         // Set the appropriate headers for downloading the zip file
         res.attachment(zipFileName);
         res.setHeader('Content-Type', 'application/zip');
-      
+
         // Stream the zip file to the response
         const readStream = fs.createReadStream(zipPath);
         readStream.pipe(res);
-      
+
         // Remove the temporary zip file once it's streamed
         readStream.on('end', () => {
-          fs.unlinkSync(zipPath);
+            fs.unlinkSync(zipPath);
         });
-      
+
         // Handle any errors that occur during the archiving process
         archive.on('error', function (err) {
-          console.log(err);
+            console.log(err);
-          res.status(500).send({ error: 'Failed to create the zip file' });
+            res.status(500).send({ error: 'Failed to create the zip file' });
         });
 
 
     }
 
 
-
+    @UseGuards(AuthGuard())
     @Get('Drawings-Arc/:id')
     async getDrawingsAsZip(
         @Param('id') id: string,
         @Res() res,
         @Req() req,
-      ) {
+    ) {
         const folderPath = path.join('./uploads/Drawings', id);
         if (!fs.existsSync(folderPath)) {
-          res.status(404).send({ error: 'File not found' });
+            res.status(404).send({ error: 'File not found' });
-          return;
+            return;
-        }  
+        }
 
         //Uncomment when we want tender id as the zip file name
         //const zipFileName = id + '.zip';
         const zipFileName = 'Drawings.zip';
         const zipPath = path.join('./uploads/Drawings', zipFileName);
-      
+
         // Create a new archive
         const archive = archiver('zip', {
-          zlib: { level: 9 } // Set compression level (optional)
+            zlib: { level: 9 } // Set compression level (optional)
         });
-      
+
         // Create a write stream to the zip file
         const output = fs.createWriteStream(zipPath);
-      
+
         // Pipe the archive to the write stream
         archive.pipe(output);
-      
+
         // Add the entire folder to the archive
         archive.directory(folderPath, id);
-      
+
         // Finalize the archive
         await archive.finalize();
-      
+
         // Set the appropriate headers for downloading the zip file
         res.attachment(zipFileName);
         res.setHeader('Content-Type', 'application/zip');
-      
+
         // Stream the zip file to the response
         const readStream = fs.createReadStream(zipPath);
         readStream.pipe(res);
-      
+
         // Remove the temporary zip file once it's streamed
         readStream.on('end', () => {
-          fs.unlinkSync(zipPath);
+            fs.unlinkSync(zipPath);
         });
-      
+
+        // Handle any errors that occur during the archiving process
+        archive.on('error', function (err) {
+            console.log(err);
+            res.status(500).send({ error: 'Failed to create the zip file' });
+        });
+
+
+    }
+
+    @UseGuards(AuthGuard())
+    @Get('user-doc-arc/:id')
+    async getUserDocsAsZip(
+        @Param('id') id: string,
+        @Res() res,
+        @Req() req,
+    ) {
+        const folderPath = path.join('./uploads/userDocuments', id);
+        if (!fs.existsSync(folderPath)) {
+            res.status(404).send({ error: 'File not found' });
+            return;
+        }
+
+        //Uncomment when we want tender id as the zip file name
+        //const zipFileName = id + '.zip';
+        const zipFileName = 'userDocuments.zip';
+        const zipPath = path.join('./uploads/userDocuments', zipFileName);
+
+        // Create a new archive
+        const archive = archiver('zip', {
+            zlib: { level: 9 } // Set compression level (optional)
+        });
+
+        // Create a write stream to the zip file
+        const output = fs.createWriteStream(zipPath);
+
+        // Pipe the archive to the write stream
+        archive.pipe(output);
+
+        // Add the entire folder to the archive
+        archive.directory(folderPath, id);
+
+        // Finalize the archive
+        await archive.finalize();
+
+        // Set the appropriate headers for downloading the zip file
+        res.attachment(zipFileName);
+        res.setHeader('Content-Type', 'application/zip');
+
+        // Stream the zip file to the response
+        const readStream = fs.createReadStream(zipPath);
+        readStream.pipe(res);
+
+        // Remove the temporary zip file once it's streamed
+        readStream.on('end', () => {
+            fs.unlinkSync(zipPath);
+        });
+
         // Handle any errors that occur during the archiving process
         archive.on('error', function (err) {
-          console.log(err);
+            console.log(err);
-          res.status(500).send({ error: 'Failed to create the zip file' });
+            res.status(500).send({ error: 'Failed to create the zip file' });
         });
 
 
     }
+
+
 }

src/file-upload/file-upload.module.ts

@@ -9,7 +9,7 @@ import { AuthModule } from 'src/auth/auth.module';
     MulterModule.register({
       dest: './uploads'
     }),
-   // AuthModule,
+     AuthModule,
   ],
   controllers: [FileUploadController],
   providers: [FileUploadService]

src/framework/beans/pcd-form-grid.controller.ts

@@ -10,7 +10,7 @@ export class PcdFormGridController<T>{
     private logger = new Logger('PcdFormGridController'); // for logging
     constructor(
         private service: PcdFormGridService<T>
-    ) { 
+    ) {
     }
 
     @Get()
@@ -28,7 +28,7 @@ export class PcdFormGridController<T>{
         @Param('id') id: string,
         @GetUser() user: PcduserDto,
     ): Promise<any> {
-       
+
         return await this.service.findOne(filterDto, id, user);
     }
 
@@ -38,7 +38,7 @@ export class PcdFormGridController<T>{
         @Body() body: T,
         @GetUser() user: PcduserDto
     ): Promise<any> {
-      
+
         return await this.service.createOne(body, user);
     }
 
@@ -59,5 +59,5 @@ export class PcdFormGridController<T>{
     ): Promise<any> {
         return await this.service.deleteOne(filter, id, user);
     }
-   
+
 }

src/framework/beans/pcd-form-grid.service.ts

@@ -13,7 +13,7 @@ export class PcdFormGridService<T> implements PcdFormGridInterface {
     MANDATORY_FEILDS: string[] = [];
     DUPLICATE_CHK: string[] = [];
     FK_FEILDS: { column: string, relation: Repository<any> }[] = [];
-    ROW_COUNT:string='';
+    ROW_COUNT: string = '';
     constructor(
         //    @Inject(TENANT_CONNECTION) conn:Connection,
         private repo: Repository<any>
@@ -277,6 +277,6 @@ export class PcdFormGridService<T> implements PcdFormGridInterface {
         return COLUMNS;
     }
 
-   
+
 
 }

src/framework/beans/pcd-transaction.controller.ts

@@ -3,6 +3,8 @@ import { AuthGuard } from "@nestjs/passport";
 import { AuthModule } from "src/auth/auth.module";
 import { FindManyOptions } from "typeorm";
 import { PcdTransactionService } from "./pcd-transaction.service";
+import { GetUser } from "src/auth/dto/get-user.decorator";
+import { PcduserDto } from "src/auth/dto/pcd-user.dto";
 
 export class PcdTransactionController<T> {
 
@@ -11,27 +13,30 @@ export class PcdTransactionController<T> {
     constructor(
         private service: PcdTransactionService<T>
     ) { }
-    @UseGuards(AuthGuard())
+
     @Get()
-    async findList(@Query() filter: FindManyOptions, ): Promise<T[]> {
+    async findList(@Query() filter: FindManyOptions,
-        return await this.service.findList(filter);
+        @GetUser() user: PcduserDto
+    ): Promise<T[]> {
+        return await this.service.findList(filter, user);
     }
 
     @Get('/:id')
-    async findOne(@Query() filter: FindManyOptions,@Param('id') id: string , ): Promise<T> {
+    async findOne(@Query() filter: FindManyOptions, @Param('id') id: string,): Promise<T> {
         return await this.service.findOne(filter, id);
     }
 
-   
+    @UseGuards(AuthGuard())
     @Post()
-    async createOne(@Body() body: T, ): Promise<T> {
+    async createOne(@Body() body: T,
-        return await this.service.createOne(body,);
+        @GetUser() user: PcduserDto): Promise<T> {
+        return await this.service.createOne(body, user);
     }
 
 
-   
+    @UseGuards(AuthGuard())
     @Delete('/:id')
-    async delete(@Query() filter: FindManyOptions,@Param('id') id: string , ): Promise<any> {
+    async delete(@Query() filter: FindManyOptions, @Param('id') id: string,): Promise<any> {
-        return await this.service.deleteOne(filter,id, );
+        return await this.service.deleteOne(filter, id,);
     }
 }

src/framework/beans/pcd-transaction.service.ts

@@ -1,7 +1,8 @@
-import {  PcdtTransactionInterface } from "../interface/pcd-transaction.interface";
+import { PcdtTransactionInterface } from "../interface/pcd-transaction.interface";
 import { FindManyOptions, Repository, getConnection, QueryRunner, Connection } from "typeorm";
 import { BadRequestException, NotAcceptableException, UnauthorizedException, InternalServerErrorException, MethodNotAllowedException, HttpException, Inject } from "@nestjs/common";
 import { TransactionDetailDto } from "src/framework/custom/transaction-detail.dto";
+import { PcduserDto } from "src/auth/dto/pcd-user.dto";
 //import { TENANT_CONNECTION } from "src/tenant/tenant.module";
 // import { IintDto } from "../../dto/iint.dto";
 // import { IintvrnoDto } from "../../dto/iintvrno.dto";
@@ -10,7 +11,7 @@ import { TransactionDetailDto } from "src/framework/custom/transaction-detail.dt
 export class PcdTransactionService<T> implements PcdtTransactionInterface {
 
     MAIN_KEY: string = "id";
-    TXN_TYPE:string="";
+    TXN_TYPE: string = "";
 
     DETAIL_DATA_FORMAT: TransactionDetailDto[] = [];
 
@@ -19,32 +20,32 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
         private repo: Repository<any>
     ) { }
 
-    async preFindList(filter: FindManyOptions, ): Promise<boolean> {
+    async preFindList(filter: FindManyOptions, user: PcduserDto): Promise<boolean> {
         return true
     }
 
-    async findList(filter: FindManyOptions, ): Promise<T[]> {
+    async findList(filter: FindManyOptions, user: PcduserDto): Promise<T[]> {
         if (!filter.where) filter.where = {};
         if (this.TXN_TYPE) filter.where[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
         // if (!filter.where[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName])
         //     return;
 
-        if (!await this.preFindList(filter))
+        if (!await this.preFindList(filter, user))
             throw new BadRequestException(`Unexpected Error Occured in findList`);
         let result: T[] = await this.repo.find(filter);
 
-        return await this.postFindList(filter,  result);
+        return await this.postFindList(filter, result);
     }
 
     async postFindList(filter: FindManyOptions, result: T[]): Promise<T[]> {
         return result;
     }
 
-    async preFindOne(filter: FindManyOptions, ): Promise<boolean> {
+    async preFindOne(filter: FindManyOptions,): Promise<boolean> {
         return true
     }
 
-    async findOne(filter: FindManyOptions, id: string | number, ): Promise<T> {
+    async findOne(filter: FindManyOptions, id: string | number,): Promise<T> {
         if (!filter.where) filter.where = {};
         if (this.TXN_TYPE) filter.where[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
         let orgFilter = Object.create(filter);
@@ -61,18 +62,18 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
 
         result = await this.getDetailData(result, orgFilter, this.DETAIL_DATA_FORMAT);
 
-        return await this.postFindOne(filter,  result);
+        return await this.postFindOne(filter, result);
     }
 
     async postFindOne(filter: FindManyOptions, result: T): Promise<T> {
         return result;
     }
 
-    async preDeleteOne(filter: FindManyOptions, id: string | number, ): Promise<boolean> {
+    async preDeleteOne(filter: FindManyOptions, id: string | number,): Promise<boolean> {
         return true;
     }
 
-    async deleteOne(filter: any, id: string | number, ): Promise<any> {
+    async deleteOne(filter: any, id: string | number,): Promise<any> {
         if (!filter || !filter.where) filter.where = {};
         if (this.TXN_TYPE) filter.where[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
         filter.where[this.MAIN_KEY] = id;
@@ -86,15 +87,15 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
         await queryRunner.connect();
         try {
             await queryRunner.startTransaction();
-            await this.deleteDetailDataTabels(id,  this.DETAIL_DATA_FORMAT, queryRunner);
+            await this.deleteDetailDataTabels(id, this.DETAIL_DATA_FORMAT, queryRunner);
             const result = await queryRunner.manager.delete(this.repo.metadata.name, id);
             await queryRunner.commitTransaction();
-            return await this.postDeleteOne(filter,  result);
+            return await this.postDeleteOne(filter, result);
         } catch (err) {
             if (queryRunner.isTransactionActive)
                 await queryRunner.rollbackTransaction();
             throw new InternalServerErrorException(`${err.message}`);
-        }finally{
+        } finally {
             await queryRunner.release();
         }
         // const result = await this.repo.delete(delFilter);
@@ -105,7 +106,7 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
         return result;
     }
 
-    async preCreateOne(body: T, ): Promise<boolean> {
+    async preCreateOne(body: T,): Promise<boolean> {
         return true;
     }
 
@@ -113,9 +114,9 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
         return true;
     }
 
-    async createOne(body: T, ): Promise<T> {
+    async createOne(body: T, user: PcduserDto): Promise<T> {
         //console.log('--- incoming = ', body);
-            
+
         if (this.TXN_TYPE) body[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
         if (!await this.preCreateOne(body))
             throw new BadRequestException(`Unexpected Error Occured in CreateOne`);
@@ -126,24 +127,24 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
         await queryRunner.connect();
         try {
             await queryRunner.startTransaction();
-            
+
-        if (this.TXN_TYPE) body[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
+            if (this.TXN_TYPE) body[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
             // await this.checkAndSetVrNo(body, user, queryRunner);
 
             // for deleting deleted details from the angular
             for (let row of this.DETAIL_DATA_FORMAT) {
-                body[row.detailName] = await this.deleteDetailData(body[row.detailName],  row, queryRunner);
+                body[row.detailName] = await this.deleteDetailData(body[row.detailName], row, queryRunner);
             }
-            
+
 
             body["createdBy"] = 'SYSTEM';
-           body["modifiedBy"] = 'SYSTEM';
+            body["modifiedBy"] = 'SYSTEM';
-            if (!await this.beforeCreateOne(body,  queryRunner))
+            if (!await this.beforeCreateOne(body, queryRunner))
                 throw new BadRequestException(`Unepected Error Occured in CreateOne`);
 
             const data = await queryRunner.manager.save(this.repo.metadata.name, body);
-            await this.insertDetailData(body,  this.DETAIL_DATA_FORMAT, queryRunner, data);
+            await this.insertDetailData(body, this.DETAIL_DATA_FORMAT, queryRunner, data);
-            
+
             await this.afterCreateOne(body);
             await queryRunner.commitTransaction();
 
@@ -151,7 +152,7 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
             const filter: FindManyOptions = await this.getFilterWithPrimaryKey(body);
             const result = await this.findOne(filter, data[this.MAIN_KEY]);
 
-            return await this.postCreateOne(body,  result);
+            return await this.postCreateOne(body, result);
 
         } catch (err) {
             // since we have errors lets rollback changes we made
@@ -195,30 +196,30 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
     }
 
     async insertDetailData(body: T, detailData: TransactionDetailDto[], queryRunner: QueryRunner, insertedData: T): Promise<void> {
-        
+
         for (let row of detailData) {
-            await this.insertDetailData2ndLevel(body[row.detailName],  row, queryRunner, insertedData, insertedData);
+            await this.insertDetailData2ndLevel(body[row.detailName], row, queryRunner, insertedData, insertedData);
         }
     }
 
-    async deleteDetailDataTabels(id: string | number,  detailDataFormat: TransactionDetailDto[], queryRunner: QueryRunner): Promise<any> {
+    async deleteDetailDataTabels(id: string | number, detailDataFormat: TransactionDetailDto[], queryRunner: QueryRunner): Promise<any> {
         for (let row of detailDataFormat) {
-            await this.deleteDetailTableData(id,  row, queryRunner);
+            await this.deleteDetailTableData(id, row, queryRunner);
         }
     }
 
-    async deleteDetailTableData(id: string | number,  detailData: TransactionDetailDto, queryRunner: QueryRunner): Promise<any> {
+    async deleteDetailTableData(id: string | number, detailData: TransactionDetailDto, queryRunner: QueryRunner): Promise<any> {
         if (detailData.childDetail && detailData.childDetail.length > 0) {
             for (let child of detailData.childDetail) {
-                await this.deleteDetailTableData(id,  child, queryRunner);
+                await this.deleteDetailTableData(id, child, queryRunner);
             }
         }
         if (id) {
             let filter = {};
-            if(detailData.foreignKeyColumnName) {
+            if (detailData.foreignKeyColumnName) {
                 filter[detailData.foreignKeyColumnName] = id;
-            
+
-            }else{
+            } else {
                 filter[detailData.foreignKeyAssignmentColumnName.columnName] = id;
             }
             await queryRunner.manager.delete(detailData.repo.metadata.name, filter);
@@ -235,7 +236,7 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
                                 detData["crud"] = "D";
                             }
                         }
-                        row[child.detailName] = await this.deleteDetailData(row[child.detailName],  child, queryRunner);
+                        row[child.detailName] = await this.deleteDetailData(row[child.detailName], child, queryRunner);
                     }
                 }
             }
@@ -250,7 +251,7 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
     }
 
     async insertDetailData2ndLevel(body: T[], detailData: TransactionDetailDto, queryRunner: QueryRunner, headerData: T, detailHeaderData: T): Promise<void> {
-         
+
         let deatilInsResult: any;
         let eagerCols: any = await this.getEagerColumns(detailData.repo);
         if (body) {
@@ -258,13 +259,13 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
                 for (let col of eagerCols) {
                     delete row[col];
                 }
-        if (this.TXN_TYPE) row[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
+                if (this.TXN_TYPE) row[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
-                 if(detailData.foreignKeyColumnName){
+                if (detailData.foreignKeyColumnName) {
-                    row[detailData.foreignKeyColumnName]=headerData[this.MAIN_KEY];
+                    row[detailData.foreignKeyColumnName] = headerData[this.MAIN_KEY];
-                }else{
+                } else {
-                
+
-                row[detailData.foreignKeyAssignmentColumnName.columnName] 
+                    row[detailData.foreignKeyAssignmentColumnName.columnName]
-                = detailHeaderData[detailData.foreignKeyAssignmentColumnName.headerColumn];
+                        = detailHeaderData[detailData.foreignKeyAssignmentColumnName.headerColumn];
                 }
                 row["createdBy"] = 'SYSTEM';
                 row["modifiedBy"] = 'SYSTEM';
@@ -278,11 +279,11 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
                 if (detailData.childDetail && detailData.childDetail.length > 0) {
                     for (let child of detailData.childDetail) {
                         if (body && body.length > 0) {
-                                await this.insertDetailData2ndLevel(row[child.detailName],  child, queryRunner, headerData, deatilInsResult);
+                            await this.insertDetailData2ndLevel(row[child.detailName], child, queryRunner, headerData, deatilInsResult);
                         }
                     }
                 }
-            } 
+            }
         }
 
     }

src/tables/covers-lov/covers-lov.entity.ts

@@ -1,6 +1,7 @@
 import { PcdBaseDto } from "src/framework/custom/pcd-dto.custom";
 import { PcdBaseEntity } from "src/framework/custom/pcd-entity.custom";
-import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { CoverDoc } from "../covers-master/covers-master.entity";
 
 @Entity('covers-lov')
 export class CoversLov extends PcdBaseEntity{
@@ -18,4 +19,7 @@ export class CoversLov extends PcdBaseEntity{
     })
     coverType:string
 
+    @OneToMany(() => CoverDoc, (coverDoc) => coverDoc.coverTypeD )
+    coverDoc:CoverDoc[]
+
 } 

src/tables/covers-master/covers-master.controller.ts

@@ -1,4 +1,16 @@
 import { Controller } from '@nestjs/common';
+import { CoverMasterDto } from 'src/dto/cover-master.dto';
+import { PcdFormGridController } from 'src/framework/beans/pcd-form-grid.controller';
+import { CoversMasterService } from './covers-master.service';
 
 @Controller('covers-master')
-export class CoversMasterController {}
+export class CoversMasterController extends PcdFormGridController<CoverMasterDto>{
+
+    constructor(
+        private coversMasterService: CoversMasterService
+    ) {
+        super(coversMasterService);
+    }
+
+}
+

src/tables/covers-master/covers-master.entity.ts

@@ -1,47 +1,56 @@
 import { PcdBaseEntity } from "src/framework/custom/pcd-entity.custom";
 import { TenderMaster } from "src/tables/tender-master/tender-master.entity";
-import { Column, Entity, JoinColumn, ManyToOne, PrimaryColumn } from "typeorm";
+import { Column, Entity, JoinColumn, ManyToOne, PrimaryColumn, PrimaryGeneratedColumn } from "typeorm";
+import { CoversLov } from "../covers-lov/covers-lov.entity";
+import { FileFormat } from "../file-format-lov/file-format-lov.entity";
 
 @Entity('cover-doc-master')
-export class CoverDoc extends PcdBaseEntity{
+export class CoverDoc extends PcdBaseEntity {
 
-    @PrimaryColumn({
+    @PrimaryGeneratedColumn({
-        name:"id"
+        name: "id"
     })
-    id:number
+    id: number
     @Column({
-        name:"tender_id",
+        name: "tender_id",
-        type:"numeric",
+        type: "numeric",
         //length:500,
-        nullable:true
+        nullable: true
     })
-    tenderId:number
+    tenderId: number
     @Column({
-        name:"cover_type",
+        name: "cover_type",
-        type:"varchar",
+        type: "numeric",
-       length:500,
+
-        nullable:true
+        nullable: true
     })
-    coverType:string
+    coverType: string
     @Column({
-        name:"desc",
+        name: "desc",
-        type:"varchar",
+        type: "varchar",
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    Description:string
+    Description: string
 
     @Column({
-        name:"file_format",
+        name: "file_format",
-        type:"varchar",
+        type: "numeric",
-        length:500,
+
-        nullable:true
+        nullable: true
     })
-    fileFormat:string
+    fileFormat: string
 
-    @ManyToOne(() => TenderMaster,(tenderMaster)=> tenderMaster.coverDoc)
+    @ManyToOne(() => TenderMaster, (tenderMaster) => tenderMaster.coverDoc)
     @JoinColumn([{ name: "tender_id", referencedColumnName: "id" }])
-    tenderIdD:TenderMaster
+    tenderIdD: TenderMaster
+
+    @ManyToOne(() => CoversLov, (coversLov) => coversLov.coverType, { eager: true })
+    @JoinColumn([{ name: "cover_type", referencedColumnName: "id" }])
+    coverTypeD: CoversLov
 
+    @ManyToOne(() => FileFormat, (fileFormat) => fileFormat.fileFormat, { eager: true })
+    @JoinColumn([{ name: "file_format", referencedColumnName: "id" }])
+    fileFormatD: FileFormat
 
-}
+} 

src/tables/covers-master/covers-master.module.ts

@@ -1,8 +1,15 @@
 import { Module } from '@nestjs/common';
 import { CoversMasterService } from './covers-master.service';
 import { CoversMasterController } from './covers-master.controller';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AuthModule } from 'src/auth/auth.module';
+import { CoverMasterRepository } from './covers-master.repository';
 
 @Module({
+  imports: [
+    TypeOrmModule.forFeature([CoverMasterRepository]),
+    AuthModule
+  ],
   providers: [CoversMasterService],
   controllers: [CoversMasterController]
 })

src/tables/covers-master/covers-master.repository.ts

@@ -2,6 +2,6 @@ import { EntityRepository, Repository } from "typeorm";
 import { CoverDoc } from "./covers-master.entity";
 
 @EntityRepository(CoverDoc)
-export class importantDocRepository extends Repository<CoverDoc>{
+export class CoverMasterRepository extends Repository<CoverDoc>{
 
 }

src/tables/covers-master/covers-master.service.ts

@@ -1,4 +1,17 @@
 import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { CoverMasterDto } from 'src/dto/cover-master.dto';
+import { PcdFormGridService } from 'src/framework/beans/pcd-form-grid.service';
+import { CoverMasterRepository } from './covers-master.repository';
 
 @Injectable()
-export class CoversMasterService {}
+export class CoversMasterService extends PcdFormGridService<CoverMasterDto>{
+
+    constructor(
+        @InjectRepository(CoverMasterRepository)
+        private coverMasterRepository: CoverMasterRepository,
+    ) {
+        super(coverMasterRepository);
+    }
+
+} 

src/tables/file-format-lov/file-format-lov.entity.ts

@@ -1,5 +1,6 @@
 import { PcdBaseEntity } from "src/framework/custom/pcd-entity.custom";
-import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from "typeorm";
+import { CoverDoc } from "../covers-master/covers-master.entity";
 
 @Entity('file-format')
 export class FileFormat extends PcdBaseEntity{
@@ -15,4 +16,7 @@ export class FileFormat extends PcdBaseEntity{
         nullable:true
     })
     fileFormat:string
+
+    @OneToMany(() => CoverDoc, (coverDoc) => coverDoc.fileFormatD )
+    coverDoc:CoverDoc[]
 }

src/tables/form-of-contract/form-of-contract.module.ts

@@ -1,7 +1,6 @@
 import { Module } from '@nestjs/common';
 import { FormOfContractController } from './form-of-contract.controller';
 import { FormOfContractService } from './form-of-contract.service';
-import { typeOrmConfig } from 'src/config/typeorm.config';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { FormOfContractRepository } from './form-of-contract.repository';
 import { AuthModule } from 'src/auth/auth.module';

src/tables/tender-documents/tender-doc.entity.ts

@@ -48,7 +48,7 @@ export class TenderDoc extends PcdBaseEntity{
    type:"varchar",
    nullable:true
  })
-docCategory:string
+ documentCategory:string
  
  @ManyToOne(() => TenderMaster,(tenderMaster)=> tenderMaster.TenderDoc)
  @JoinColumn([{ name: "tender_id", referencedColumnName: "id" }])

src/tables/tender-master/tender-master.entity.ts

@@ -11,386 +11,386 @@ import { Column, Entity, JoinColumn, ManyToOne, OneToMany, PrimaryColumn, Primar
 import { CoverDoc } from "../covers-master/covers-master.entity";
 
 @Entity('tender_master')
-export class TenderMaster extends PcdBaseEntity{
+export class TenderMaster extends PcdBaseEntity {
 
     @PrimaryGeneratedColumn({
-        name:'id'
+        name: 'id'
     })
-        id:number
+    id: number
     @Column({
-        name:'org_chain',
+        name: 'org_chain',
-        type:'varchar',
+        type: 'varchar',
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    orgChain:string
+    orgChain: string
     @Column({
-        name:'tender_ref_no',
+        name: 'tender_ref_no',
-        type:"varchar",
+        type: "varchar",
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    tenderRefNo:string
+    tenderRefNo: string
     @Column({
-        name:"tender_id",
+        name: "tender_id",
-        type:'varchar',
+        type: 'varchar',
-        length:510,
+        length: 510,
-        nullable:true
+        nullable: true
     })
-    tenderId:string
+    tenderId: string
     @Column({
-        name:"allow_tech_eval",
+        name: "allow_tech_eval",
-        type:"char",
+        type: "char",
-        length:1,
+        length: 1,
-        nullable:true
+        nullable: true
     })
-    allowTechEval:string
+    allowTechEval: string
 
     @Column({
-        name:"payment_mode",
+        name: "payment_mode",
-        type:'numeric',
+        type: 'numeric',
-        nullable:true
+        nullable: true
     })
-    paymentMode:number
+    paymentMode: number
     @Column({
-        name:'allow_withdraw',
+        name: 'allow_withdraw',
-        type :'char',
+        type: 'char',
-        length:1,
+        length: 1,
-        nullable:true
+        nullable: true
     })
-    allowWithdraw:string
+    allowWithdraw: string
     @Column({
-        name:'no_of_covers',
+        name: 'no_of_covers',
-        type:'int',
+        type: 'int',
-        nullable:true,
+        nullable: true,
         default: () => "(0)"
     })
-    noOfCovers:string
+    noOfCovers: string
     @Column({
-        name:'itemwise_tech_eval',
+        name: 'itemwise_tech_eval',
-        type:'char',
+        type: 'char',
-        length:1,
+        length: 1,
-        nullable:true
+        nullable: true
     })
-    itemwiseTechEval:string
+    itemwiseTechEval: string
     @Column({
-        name:'allow_two_stage',
+        name: 'allow_two_stage',
-        type:'char',
+        type: 'char',
-        length:1,
+        length: 1,
-        nullable:true
+        nullable: true
     })
-    allowTwoStageBid:string
+    allowTwoStageBid: string
 
     @Column({
-        name:'tender_fee',
+        name: 'tender_fee',
-        type:'int',
+        type: 'int',
-        nullable:true
+        nullable: true
-        
+
     })
-    tenderFee:string
+    tenderFee: string
     @Column({
-        name:'fee_pay_to',
+        name: 'fee_pay_to',
-        type:"varchar",
+        type: "varchar",
-        length:100,
+        length: 100,
-        default:()=>"'Nil'"
+        default: () => "'Nil'"
     })
-    feePayableTo:string
+    feePayableTo: string
     @Column({
-        name:'fee_pay_at',
+        name: 'fee_pay_at',
-        type:"varchar",
+        type: "varchar",
-        length:100,
+        length: 100,
-        default:()=>"'Nil'"
+        default: () => "'Nil'"
     })
-    feePayableAt:string
+    feePayableAt: string
     @Column({
-        name:"t_fee_Exemption",
+        name: "t_fee_Exemption",
-        type:"char",
+        type: "char",
-        length:1,
+        length: 1,
-        nullable:true
+        nullable: true
     })
-    tenderFeeExemption:string
+    tenderFeeExemption: string
     @Column({
-        name:'emd_amt',
+        name: 'emd_amt',
-        type:'int',
+        type: 'int',
-        nullable:true
+        nullable: true
     })
-    emdAmt:string
+    emdAmt: string
     @Column({
-        name:"emd_payable_to",
+        name: "emd_payable_to",
-        type:"varchar",
+        type: "varchar",
-        length:100,
+        length: 100,
-        default :() =>"'Nil'"
+        default: () => "'Nil'"
     })
-    emdPayableTo:string
+    emdPayableTo: string
     @Column({
-        name:"allow_emd_bg_st",
+        name: "allow_emd_bg_st",
-        type:"char",
+        type: "char",
-        length:1,
+        length: 1,
-        nullable:true
+        nullable: true
     })
-    allowEmdBgOrSt:string
+    allowEmdBgOrSt: string
     @Column({
-        name:"emd_percentage",
+        name: "emd_percentage",
-        type:"int",
+        type: "int",
-        nullable:true
+        nullable: true
     })
-    emdPercentage:string
+    emdPercentage: string
     @Column({
-        name:"emd_payable_at",
+        name: "emd_payable_at",
-        type:"varchar",
+        type: "varchar",
-        length:100,
+        length: 100,
-        default:() =>"'Nil'"
+        default: () => "'Nil'"
     })
-    emdPayableAt:string
+    emdPayableAt: string
     @Column({
-        name:"title",
+        name: "title",
-        type:'varchar',
+        type: 'varchar',
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
-      })
+    })
-      title:string
+    title: string
     @Column({
-        name:"work_desc",
+        name: "work_desc",
-        type:'varchar',
+        type: 'varchar',
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    workDesc:string
+    workDesc: string
     @Column({
-        name:"nda_pre_quali",
+        name: "nda_pre_quali",
-        type:"varchar",
+        type: "varchar",
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    ndaPreQualification:string
+    ndaPreQualification: string
     @Column({
-        name:"remarks",
+        name: "remarks",
-        type:"varchar",
+        type: "varchar",
-        length:500,
+        length: 500,
-        default:()=>"'NA'"
+        default: () => "'NA'"
     })
-    remarks:string
+    remarks: string
     @Column({
-        name:"tender_value",
+        name: "tender_value",
-        type:"int",
+        type: "int",
-        nullable:true
+        nullable: true
     })
-    tenderValue:string
+    tenderValue: string
     @Column({
-        name:"contract_type",
+        name: "contract_type",
-        type:"varchar",
+        type: "varchar",
-        length:200,
+        length: 200,
-        nullable:true
+        nullable: true
     })
-    contractType:string
+    contractType: string
     @Column({
-        name:"location",
+        name: "location",
-        type :"varchar",
+        type: "varchar",
-        length:200,
+        length: 200,
-        nullable:true
+        nullable: true
     })
-    location:string
+    location: string
     @Column({
-        name:"pre_bid_meet_add",
+        name: "pre_bid_meet_add",
-        type:"varchar",
+        type: "varchar",
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    preBidMeetAdd:string
+    preBidMeetAdd: string
     @Column({
-        name:"allow_nda_tender",
+        name: "allow_nda_tender",
-        type:"char",
+        type: "char",
-        length:1,
+        length: 1,
-        nullable:true
+        nullable: true
     })
-    allowNdaTender:string
+    allowNdaTender: string
     @Column({
-        name:"product_cat",
+        name: "product_cat",
-        type:"varchar",
+        type: "varchar",
-        nullable:true
+        nullable: true
     })
-    productCategory:string
+    productCategory: string
     @Column({
-        name:"bid_validity",
+        name: "bid_validity",
-        type:'int',
+        type: 'int',
-        nullable:true
+        nullable: true
     })
-    bidValidity:string
+    bidValidity: string
     @Column({
-        name:"pincode",
+        name: "pincode",
-        type:"int",
+        type: "int",
-        nullable:true
+        nullable: true
     })
-    pincode:string
+    pincode: string
     @Column({
-        name:"pre_bid_date",
+        name: "pre_bid_date",
-        type:"timestamp",
+        type: "timestamp",
-        nullable:true
+        nullable: true
     })
-    preBidDate:Date
+    preBidDate: Date
     @Column({
-        name:"allow_prefer_bidder",
+        name: "allow_prefer_bidder",
-        type:"char",
+        type: "char",
-        length:1,
+        length: 1,
-        nullable:true
+        nullable: true
     })
-    allowPreferencialBidder:string
+    allowPreferencialBidder: string
     @Column({
-        name:"sub_category",
+        name: "sub_category",
-        type:"varchar",
+        type: "varchar",
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    subCategory:string
+    subCategory: string
     @Column({
-        name:"period_of_work",
+        name: "period_of_work",
-        type:"int",
+        type: "int",
-        nullable:true
+        nullable: true
     })
-    periodOfWork:string
+    periodOfWork: string
     @Column({
-        name:"pre_meet_place",
+        name: "pre_meet_place",
-        type:"varchar",
+        type: "varchar",
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    preBidMeetPlace:string
+    preBidMeetPlace: string
     @Column({
-        name:"bid_open_place",
+        name: "bid_open_place",
-        type:"varchar",
+        type: "varchar",
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    bidOpeningPlace:string
+    bidOpeningPlace: string
     @Column({
-        name:"publish_date",
+        name: "publish_date",
-        type:"timestamp",
+        type: "timestamp",
-        nullable:true
+        nullable: true
     })
-    publishDate:Date
+    publishDate: Date
     @Column({
-        name:"sale_start_date",
+        name: "sale_start_date",
-        type:"timestamp",
+        type: "timestamp",
-        nullable:true
+        nullable: true
     })
-    saleStartDate:Date
+    saleStartDate: Date
     @Column({
-        name:"clarification_start_d",
+        name: "clarification_start_d",
-        type:"timestamp",
+        type: "timestamp",
-        nullable:true
+        nullable: true
     })
-    clarificationStartDate:Date
+    clarificationStartDate: Date
     @Column({
-        name:"bid_sub_start_date",
+        name: "bid_sub_start_date",
-        type:"timestamp",
+        type: "timestamp",
-        nullable:true
+        nullable: true
     })
-    bidSubStartDate:Date
+    bidSubStartDate: Date
     @Column({
-        name:"bid_open_date",
+        name: "bid_open_date",
-        type:"timestamp",
+        type: "timestamp",
-        nullable:true
+        nullable: true
     })
-    bidOpenDate:Date
+    bidOpenDate: Date
     @Column({
-        name:"sale_end_date",
+        name: "sale_end_date",
-        type:"timestamp",
+        type: "timestamp",
-        nullable:true
+        nullable: true
     })
-    saleEndDate:Date
+    saleEndDate: Date
     @Column({
-        name:"clarification_end_d",
+        name: "clarification_end_d",
-        type:"timestamp",
+        type: "timestamp",
-        nullable:true
+        nullable: true
     })
-    clarificationEndDate:Date
+    clarificationEndDate: Date
     @Column({
-        name:"bid_sub_end_date",
+        name: "bid_sub_end_date",
-        type:"timestamp",
+        type: "timestamp",
-        nullable:true
+        nullable: true
     })
-    bidSubEndDate:Date
+    bidSubEndDate: Date
     @Column({
-        name:"tender_inv_name",
+        name: "tender_inv_name",
-        type:"varchar",
+        type: "varchar",
-        length:100,
+        length: 100,
-        nullable:true
+        nullable: true
     })
-    tenderInvName:string
+    tenderInvName: string
     @Column({
-        name:"tender_inv_address",
+        name: "tender_inv_address",
-        type:"varchar",
+        type: "varchar",
-        length:500,
+        length: 500,
-        nullable:true
+        nullable: true
     })
-    tenderInvAddess:string
+    tenderInvAddess: string
     @Column({
-        name:"tender_type",
+        name: "tender_type",
-        type:"numeric",
+        type: "numeric",
-        nullable:true
+        nullable: true
     })
-    tenderType:number
+    tenderType: number
     @Column({
-        name:"tender_category",
+        name: "tender_category",
-        type:"numeric",
+        type: "numeric",
-        nullable:true
+        nullable: true
     })
-    tenderCategory:number
+    tenderCategory: number
     @Column({
-        name:"form_of_contract",
+        name: "form_of_contract",
-        type:"numeric",
+        type: "numeric",
-        nullable:true
+        nullable: true
     })
-    formOfContract:number
+    formOfContract: number
     @Column({
-        name:"emd_fee_type",
+        name: "emd_fee_type",
-        type:"varchar",
+        type: "varchar",
-        nullable:true
+        nullable: true
     })
-    emd_fee_type:string
+    emdFeeType: string
 
-    @Column({ 
+    @Column({
-        name:"activeyn",
+        name: "activeyn",
-        type:"varchar",
+        type: "varchar",
-        length:1,
+        length: 1,
-        nullable:true
+        nullable: true
     })
-    activeYn:string
+    activeYn: string
 
 
-    @OneToMany(() => CoverDoc, (coverDoc) => coverDoc.tenderIdD )
+    @OneToMany(() => CoverDoc, (coverDoc) => coverDoc.tenderIdD)
-    coverDoc:CoverDoc[]
+    coverDoc: CoverDoc[]
 
-    @OneToMany(() => paymentInstrument, (paymentInstrument) => paymentInstrument.tenderIdD )
+    @OneToMany(() => paymentInstrument, (paymentInstrument) => paymentInstrument.tenderIdD)
-    paymentInstrument:paymentInstrument[]
+    paymentInstrument: paymentInstrument[]
 
-    @OneToMany(() => TenderDoc, (TenderDoc) => TenderDoc.tenderIdD )
+    @OneToMany(() => TenderDoc, (TenderDoc) => TenderDoc.tenderIdD)
-    TenderDoc:TenderDoc[]
+    TenderDoc: TenderDoc[]
 
-    @ManyToOne(() => TenderType,(tenderType)=> tenderType.tenderMaster,{eager:true})
+    @ManyToOne(() => TenderType, (tenderType) => tenderType.tenderMaster, { eager: true })
     @JoinColumn([{ name: "tender_type", referencedColumnName: "id" }])
-    tenderTypeD:TenderType
+    tenderTypeD: TenderType
 
-    @ManyToOne(() => TenderCategory,(tenderCategory)=> tenderCategory.tenderMaster,{eager:true})
+    @ManyToOne(() => TenderCategory, (tenderCategory) => tenderCategory.tenderMaster, { eager: true })
     @JoinColumn([{ name: "tender_category", referencedColumnName: "id" }])
-    tenderCategoryD:TenderCategory
+    tenderCategoryD: TenderCategory
 
 
-    @ManyToOne(() => PaymentMode,(paymentMode)=> paymentMode.tenderMaster,{eager:true})
+    @ManyToOne(() => PaymentMode, (paymentMode) => paymentMode.tenderMaster, { eager: true })
     @JoinColumn([{ name: "payment_mode", referencedColumnName: "id" }])
-    paymentModeD:PaymentMode
+    paymentModeD: PaymentMode
 
-    @ManyToOne(() => FormOfContract,(formOfContract)=> formOfContract.tenderMaster,{eager:true})
+    @ManyToOne(() => FormOfContract, (formOfContract) => formOfContract.tenderMaster, { eager: true })
     @JoinColumn([{ name: "form_of_contract", referencedColumnName: "id" }])
-    formOfContractD:FormOfContract
+    formOfContractD: FormOfContract
 
-    @ManyToOne(() => ProductCategory,(productCategory)=> productCategory.tenderMaster,{eager:true})
+    @ManyToOne(() => ProductCategory, (productCategory) => productCategory.tenderMaster, { eager: true })
     @JoinColumn([{ name: "product_cat", referencedColumnName: "id" }])
-    productCategoryD:ProductCategory
+    productCategoryD: ProductCategory
 
-    @ManyToOne(() => EmdFeeType,(EmdFeeType)=> EmdFeeType.tenderMaster,{eager:true})
+    @ManyToOne(() => EmdFeeType, (EmdFeeType) => EmdFeeType.tenderMaster, { eager: true })
     @JoinColumn([{ name: "emd_fee_type", referencedColumnName: "id" }])
-    emdFeeTypeD:ProductCategory
+    emdFeeTypeD: ProductCategory
-   
+
 }
 

src/transactions/tender/tender.controller.ts

@@ -1,4 +1,4 @@
-import { Controller,UseGuards } from '@nestjs/common';
+import { Body, Controller, Get, UseGuards } from '@nestjs/common';
 import { TenderDetailDto } from 'src/dto/tender-master.dto';
 import { PcdTransactionController } from 'src/framework/beans/pcd-transaction.controller';
 import { TenderService } from './tender.service';
@@ -11,4 +11,11 @@ export class TenderController extends PcdTransactionController<TenderDetailDto>
         private tenderService: TenderService
     ) {
         super(tenderService);
-    }}
+    }
+
+    @Get('admin')
+    async getTender() {
+        return this.tenderService.GetAdminTenderD()
+    }
+
+}

src/transactions/tender/tender.module.ts

@@ -8,6 +8,7 @@ import { AuthModule } from 'src/auth/auth.module';
 @Module({
   imports: [
     TypeOrmModule.forFeature([TenderMasterRepository]),
+    AuthModule
   ],
   controllers: [TenderController],
   providers: [TenderService]

src/transactions/tender/tender.service.ts

@@ -1,11 +1,13 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
+import { PcduserDto } from 'src/auth/dto/pcd-user.dto';
 import { TenderDetailDto } from 'src/dto/tender-master.dto';
 import { PcdTransactionService } from 'src/framework/beans/pcd-transaction.service';
 import { TransactionDetailDto } from 'src/framework/custom/transaction-detail.dto';
+import { CoverMasterRepository } from 'src/tables/covers-master/covers-master.repository';
 import { tenderDocRepository } from 'src/tables/tender-documents/tender-doc.repository';
 import { TenderMasterRepository } from 'src/tables/tender-master/tender-master.repository';
-import { Connection } from 'typeorm';
+import { Connection, FindManyOptions, LessThanOrEqual, MoreThanOrEqual } from 'typeorm';
 
 @Injectable()
 export class TenderService extends PcdTransactionService<TenderDetailDto>{
@@ -13,7 +15,15 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
 
     DETAIL_DATA_FORMAT: TransactionDetailDto[] = [
         {
-           detailName: "tenderDoc", repo: this.conn.getCustomRepository(tenderDocRepository),
+            detailName: "tenderDoc", repo: this.conn.getCustomRepository(tenderDocRepository),
+            filter: [{ columnName: "tenderId", headerColumn: "id" }],
+            foreignKeyColumnName: "tenderId",
+            childDetail: [],
+            addtionalSettingOfRowsInInsertion: [],
+            orderByColumn: { columnName: "id", sort: "DESC" }
+        },
+        {
+            detailName: "covers", repo: this.conn.getCustomRepository(CoverMasterRepository),
             filter: [{ columnName: "tenderId", headerColumn: "id" }],
             foreignKeyColumnName: "tenderId",
             childDetail: [],
@@ -25,9 +35,23 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
         private conn: Connection,
         @InjectRepository(TenderMasterRepository)
         private tenderMasterRepository: TenderMasterRepository,
-    ){
+    ) {
-            super(conn, conn.getCustomRepository(TenderMasterRepository));
+        super(conn, conn.getCustomRepository(TenderMasterRepository));
-          //  this.TenderMasterRepository = conn.getCustomRepository(SisPaymentDetailRepository)
+        //  this.TenderMasterRepository = conn.getCustomRepository(SisPaymentDetailRepository)
-        
+
     }
+    async preFindList(filter: FindManyOptions, user: PcduserDto): Promise<boolean> {
+        if (!filter.where) filter.where = {};
+        if (!user || user.secuLevel == 'U') {
+            filter.where["publishDate"] = LessThanOrEqual(new Date());
+            filter.where["bidOpenDate"] = MoreThanOrEqual(new Date());
+        }
+
+        return true
+    }
+
+    async GetAdminTenderD() {
+        return this.tenderMasterRepository.find()
+    }
+
 }