main
josh 3 years ago
parent 7cb0c9e694
commit 18d0d2e04d

@ -1,39 +0,0 @@
// cluster.ts
import * as cluster from 'cluster';
import * as os from 'os';
export class Cluster {
static register(workers: Number, callback: Function): void {
if (cluster.isMaster) {
console.log(`Master server started on ${process.pid}`);
//ensure workers exit cleanly
process.on('SIGINT', function () {
console.log('Cluster shutting down...');
for (var id in cluster.workers) {
cluster.workers[id].kill();
}
// exit the master process
process.exit(0);
});
var cpus = os.cpus().length;
if (workers > cpus)
workers = cpus;
for (let i = 0; i < workers; i++) {
cluster.fork();
}
cluster.on('online', function (worker) {
console.log('Worker %s is online', worker.process.pid);
});
cluster.on('exit', (worker, code, signal) => {
console.log(`Worker ${worker.process.pid} died. Restarting`);
cluster.fork();
})
} else {
callback();
}
}
}

38024
package-lock.json generated

File diff suppressed because it is too large Load Diff

@ -1,5 +1,5 @@
{ {
"name": "scb-api", "name": "scb-tender-api",
"version": "0.0.1", "version": "0.0.1",
"description": "", "description": "",
"author": "", "author": "",
@ -22,68 +22,62 @@
}, },
"dependencies": { "dependencies": {
"@nest-modules/mailer": "^1.3.22", "@nest-modules/mailer": "^1.3.22",
"@nestjs/common": "^7.6.13", "@nestjs/axios": "^3.0.0",
"@nestjs/core": "^7.6.13", "@nestjs/common": "^9.4.3",
"@nestjs/jwt": "^7.2.0", "@nestjs/core": "^9.4.3",
"@nestjs/passport": "^7.1.6", "@nestjs/jwt": "^10.0.3",
"@nestjs/platform-express": "^7.6.13", "@nestjs/passport": "^9.0.3",
"@nestjs/schedule": "^1.0.1", "@nestjs/platform-express": "^9.4.3",
"@nestjs/serve-static": "^4.0.0", "@nestjs/schedule": "^3.0.2",
"@nestjs/typeorm": "^7.1.5", "@nestjs/typeorm": "^9.0.1",
"@types/nodemailer": "^6.4.9", "@types/passport-jwt": "^3.0.8",
"@types/passport-facebook": "^2.1.11",
"archiver": "^5.3.1", "archiver": "^5.3.1",
"bcrypt": "^5.0.0", "bcrypt": "^5.1.0",
"class-transformer": "^0.4.0", "class-transformer": "^0.5.1",
"class-validator": "^0.13.1", "config": "^3.3.9",
"config": "^3.3.3", "crypto-js": "^4.1.1",
"crypto-js": "^4.0.0", "i": "^0.3.7",
"ifsc": "^2.0.11",
"js-sha512": "^0.8.0", "js-sha512": "^0.8.0",
"jspdf": "^2.3.1", "jspdf": "^2.5.1",
"jspdf-autotable": "^3.5.14", "jspdf-autotable": "^3.5.31",
"jwt-payload": "^1.0.7", "node-forge": "^1.3.1",
"node-oracledb": "^1.0.2", "npm": "^9.8.1",
"oracledb": "^5.1.0", "otp-generator": "^4.0.1",
"passport": "^0.4.1", "passport": "^0.6.0",
"passport-facebook": "^3.0.0", "passport-jwt": "^4.0.1",
"passport-google-oauth20": "^2.0.0", "payu": "^0.0.1",
"passport-jwt": "^4.0.0",
"payumoney_nodejs": "^2.0.4", "payumoney_nodejs": "^2.0.4",
"pg": "^8.5.1", "payumoney-node": "^2.0.1",
"pg": "^8.10.0",
"reflect-metadata": "^0.1.13", "reflect-metadata": "^0.1.13",
"request": "^2.88.2",
"rimraf": "^3.0.2", "rimraf": "^3.0.2",
"rxjs": "^6.6.6", "rxjs": "^7.2.0",
"sha512-crypt-ts": "^0.1.27", "typeorm": "^0.3.16",
"typeorm": "^0.2.31" "uuid": "^9.0.0"
}, },
"devDependencies": { "devDependencies": {
"@nestjs-modules/mailer": "^1.8.1", "@nestjs/cli": "^9.5.0",
"@nestjs/cli": "^7.5.6", "@nestjs/schematics": "^9.2.0",
"@nestjs/schematics": "^7.2.7", "@nestjs/testing": "^9.4.3",
"@nestjs/testing": "^7.6.13", "@types/crypto-js": "^4.1.1",
"@types/cron": "^1.7.3", "@types/express": "^4.17.13",
"@types/crypto-js": "^4.0.1", "@types/jest": "28.1.8",
"@types/express": "^4.17.11", "@types/node": "^16.0.0",
"@types/jest": "^26.0.20", "@types/supertest": "^2.0.11",
"@types/node": "^14.14.31", "@typescript-eslint/eslint-plugin": "^5.0.0",
"@types/supertest": "^2.0.10", "@typescript-eslint/parser": "^5.0.0",
"@typescript-eslint/eslint-plugin": "^4.15.2", "eslint": "^8.0.1",
"@typescript-eslint/parser": "^4.15.2", "eslint-config-prettier": "^8.3.0",
"eslint": "^7.20.0", "eslint-plugin-prettier": "^4.0.0",
"eslint-config-prettier": "^8.1.0", "jest": "28.1.3",
"eslint-plugin-prettier": "^3.3.1", "prettier": "^2.3.2",
"jest": "^26.6.3", "source-map-support": "^0.5.20",
"nodemailer": "^6.9.3",
"otp-generator": "^2.0.0",
"prettier": "^2.2.1",
"supertest": "^6.1.3", "supertest": "^6.1.3",
"ts-jest": "^26.5.2", "ts-jest": "28.0.8",
"ts-loader": "^8.0.17", "ts-loader": "^9.2.3",
"ts-node": "^9.1.1", "ts-node": "^10.0.0",
"tsconfig-paths": "^3.9.0", "tsconfig-paths": "4.1.0",
"typescript": "^4.1.5" "typescript": "^4.7.4"
}, },
"jest": { "jest": {
"moduleFileExtensions": [ "moduleFileExtensions": [

@ -21,6 +21,10 @@ import { PaymentGatewayModule } from './payment-gateway/payment-gateway.module';
import { PayuTransactionListModule } from './tables/payu-transaction-list/payu-transaction-list.module'; import { PayuTransactionListModule } from './tables/payu-transaction-list/payu-transaction-list.module';
import { PaymentStatusModule } from './tables/payment-status/payment-status.module'; import { PaymentStatusModule } from './tables/payment-status/payment-status.module';
import { PaymentMasterModule } from './tables/payment-master/payment-master.module'; import { PaymentMasterModule } from './tables/payment-master/payment-master.module';
import { CommonModule } from './tables/common/common.module';
import { DataSource } from 'typeorm';
import { ReportAuthenticationModule } from './tables/report-authentication/report-authentication.module';
@Module({ @Module({
@ -45,8 +49,13 @@ import { PaymentMasterModule } from './tables/payment-master/payment-master.modu
PaymentGatewayModule, PaymentGatewayModule,
PayuTransactionListModule, PayuTransactionListModule,
PaymentStatusModule, PaymentStatusModule,
PaymentMasterModule PaymentMasterModule,
CommonModule,
ReportAuthenticationModule,
], ],
}) })
export class AppModule { } export class AppModule {
constructor(private dataSource: DataSource) {}
}

@ -33,20 +33,11 @@ export class AuthController {
return this.authService.signIn(authCredentialDto, req.ip); return this.authService.signIn(authCredentialDto, req.ip);
} }
// @Post('/tpin')
// async validateTransactionPassword(@Body(ValidationPipe) authCredentialDto: AuthCreadentialsDto, @Req() req): Promise<any> {
// console.log(authCredentialDto);
// return this.authService.validateTransactionPassword(authCredentialDto);
// }
@Get() @Get()
async getall() { async getall() {
return this.authService return this.authService
} }
@Post('/signup') @Post('/signup')
async signUp(@Body() pcdUserDto: PcduserDto): Promise<any> { async signUp(@Body() pcdUserDto: PcduserDto): Promise<any> {
// request.connection.remoteAddress // request.connection.remoteAddress
@ -64,9 +55,11 @@ export class AuthController {
@Post('/otp/:flag') @Post('/otp/:flag')
async sendOtp( async sendOtp(
@Body() body: { email: string, custName: string, tenderName: string, bidOpenDate: string }, @Body() body: { email: string, custName: string, tenderName?: string, bidOpenDate?: string },
@Param('flag') flag: string @Param('flag') flag: string
): Promise<void> { ): Promise<void> {
console.log("helo==========================");
return await this.authService.sendOtp(body, flag); return await this.authService.sendOtp(body, flag);
} }
@ -85,53 +78,4 @@ export class AuthController {
): Promise<any> { ): Promise<any> {
return await this.authService.verifyOtp(body, flag); return await this.authService.verifyOtp(body, flag);
} }
// @Get('/encrypt/:bc')
// async encryptBankCode(@GetUser() user: Pcduser,
// @Param('bc') bankCode: string) {
// return await this.authService.encryptBankCode(bankCode);
// }
}
@UseGuards(AuthGuard())
@Controller('pcduser')
export class AuthUserController {
constructor(
private authService: AuthService
) { }
// @Put('/:id')
// async updateUser(
// @Body() body: PcduserDto,
// @GetUser() user: PcduserDto,
// @Param('id') id: string,
// ): Promise<PcduserDto> {
// return await this.authService.updateUser(body, user, id);
// }
// @Patch('change-password')
// async changePasswordCurrentUser(
// @Body(ValidationPipe) passwords: ChangePasswordDto,
// @GetUser() user: PcduserDto
// ): Promise<{ msg: string }> {
// return await this.authService.changePasswordCurrentUser(passwords, user.userId, user);
// }
// @Patch('change-tpin')
// async changeTpinCurrentUser(
// @Body(ValidationPipe) passwords: ChangePasswordDto,
// @GetUser() user: PcduserDto
// ): Promise<{ msg: string }> {
// return await this.authService.changeTransactionPinCurrentUser(passwords, user.userId, user);
// }
} }

@ -1,5 +1,5 @@
import { Module } from '@nestjs/common'; import { Module } from '@nestjs/common';
import { AuthController, AuthUserController } from './auth.controller'; import { AuthController } from './auth.controller';
import { AuthService } from './auth.service'; import { AuthService } from './auth.service';
import * as config from 'config'; import * as config from 'config';
@ -13,6 +13,8 @@ import { PcduserRepository } from './pcduser.repository';
import { PcdotpRepository } from './pcdotp.repository'; import { PcdotpRepository } from './pcdotp.repository';
import { EmailService } from 'src/email/email.service'; import { EmailService } from 'src/email/email.service';
import { EmailModule } from 'src/email/email.module'; import { EmailModule } from 'src/email/email.module';
import { Pcduser } from './pcduser.entity';
import { Pcdotp } from './pcdotp.entity';
const jwtConfig = config.get('jwt'); const jwtConfig = config.get('jwt');
@ -27,16 +29,18 @@ const jwtConfig = config.get('jwt');
} }
}), }),
TypeOrmModule.forFeature([ TypeOrmModule.forFeature([
PcduserRepository, Pcduser,
PcdotpRepository, Pcdotp,
]),EmailModule, ]),EmailModule,
], ],
controllers: [AuthController, AuthUserController], controllers: [AuthController],
providers: [ providers: [
AuthService, AuthService,
CryptoService, CryptoService,
JwtStrategy, JwtStrategy,
PcdotpRepository,
PcduserRepository

@ -39,10 +39,10 @@ export class AuthService {
constructor( constructor(
@InjectRepository(PcduserRepository) @InjectRepository(PcduserRepository)
private pcduserRepository: PcduserRepository, private readonly pcduserRepository: PcduserRepository,
private jwtService: JwtService, private jwtService: JwtService,
private crypto: CryptoService, private crypto: CryptoService,
private pcdotpRepository: PcdotpRepository, private readonly pcdotpRepository: PcdotpRepository,
private mailService: EmailService private mailService: EmailService
) { ) {
@ -55,7 +55,7 @@ export class AuthService {
async userInfo(authCredentialsDto: AuthCreadentialsDto) { async userInfo(authCredentialsDto: AuthCreadentialsDto) {
const { username, secuLevel } = authCredentialsDto; const { username, secuLevel } = authCredentialsDto;
let user = await this.pcduserRepository.findOne({ email: (username.trim()).toLocaleLowerCase() }); let user = await this.pcduserRepository.findOne({where:{ email: (username.trim()).toLocaleLowerCase() }});
if (!user) { if (!user) {
throw new BadRequestException('User Details not found') throw new BadRequestException('User Details not found')
} }
@ -78,7 +78,7 @@ export class AuthService {
async validateUserPassword(authCredentialsDto: AuthCreadentialsDto): Promise<Pcduser> { async validateUserPassword(authCredentialsDto: AuthCreadentialsDto): Promise<Pcduser> {
const { username, password } = authCredentialsDto; const { username, password } = authCredentialsDto;
let user = await this.pcduserRepository.findOne({ email: (username.trim()).toLocaleLowerCase() }); let user = await this.pcduserRepository.findOne({where:{ email: (username.trim()).toLocaleLowerCase() }});
console.log("user=============", user); console.log("user=============", user);
if (!user) { if (!user) {
throw new UnauthorizedException('User not Registered') throw new UnauthorizedException('User not Registered')
@ -396,16 +396,107 @@ export class AuthService {
subject = 'OTP' subject = 'OTP'
} }
if (flag == 'confP') {
content = `
<!doctype html>
<html lang="en-US">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<title>OTP</title>
<meta name="description" content="New Account Email Template.">
<style type="text/css">
a:hover {text-decoration: underline !important;}
</style>
</head>
<body marginheight="0" topmargin="0" marginwidth="0" style="margin: 0px; background-color: #f2f3f8;" leftmargin="0">
<!-- 100% body table -->
<table cellspacing="0" border="0" cellpadding="0" width="100%" bgcolor="#f2f3f8"
style="@import url(https://fonts.googleapis.com/css?family=Rubik:300,400,500,700|Open+Sans:300,400,600,700); font-family: 'Open Sans', sans-serif;">
<tr>
<td>
<table style="background-color: #f2f3f8; max-width:800px; margin:0 auto;" width="100%" border="0"
align="center" cellpadding="0" cellspacing="0">
<tr>
<td style="height:80px;">&nbsp;</td>
</tr>
<tr>
<td style="text-align:center;">
<a href="https://www.thrickodithanamscb.in/" title="" target="_blank">
<img width="60" src="https://www.thrickodithanamscb.in/assets/img/emblem3.png" title="logo" alt="logo">
</a>
<h3 style="font-family: "Lucida Console", "Courier New", monospace;">THRICKODITHANAM SCB</h3>
</td>
</tr>
<tr>
<td style="height:20px;">&nbsp;</td>
</tr>
<tr>
<td>
<table width="95%" border="0" align="center" cellpadding="0" cellspacing="0"
style="max-width:670px; background:#fff; border-radius:3px; text-align:center;-webkit-box-shadow:0 6px 18px 0 rgba(0,0,0,.06);-moz-box-shadow:0 6px 18px 0 rgba(0,0,0,.06);box-shadow:0 6px 18px 0 rgba(0,0,0,.06);">
<tr>
<td style="height:40px;">&nbsp;</td>
</tr>
<tr>
<td style="padding:0 35px;">
<p style="font-size:15px; color:#455056; margin:8px 0 0; line-height:24px;">
Dear ${custName} , <br>
<strong> We hope this email finds you well. We are writing to inform you that your payment for the tender documents has been successfully processed and accepted by our bank. You can now proceed to download the tender documents as per your requirement. <br><br>
Once again, we appreciate your prompt payment and cooperation. We look forward to receiving your tender submission.<br>
Thank you for your participation.<br><br>
Should you have any queries or require any clarification regarding the tender process or your submission, please contact our dedicated tender support team. You can reach us via email at tscb178@gmail.com or by calling our helpline at tel:04812441062 or tel:04812443452.<br><br>
Best regards,<br>
Thrickodithanam Service Co-operative Bank LTD No 178,<br>
Kunnumpuram, Thrickodithanam,<br> Kottayam, Kerala, 686105.</strong>.</p>
<span
style="display:inline-block; vertical-align:middle; margin:29px 0 26px; border-bottom:1px solid #cecece; width:100px;"></span>
</td>
</tr>
<tr>
<td style="height:40px;">&nbsp;</td>
</tr>
</table>
</td>
</tr>
<tr>
<td style="height:20px;">&nbsp;</td>
</tr>
<tr>
<td style="text-align:center;">
<p style="font-size:14px; color:rgba(69, 80, 86, 0.7411764705882353); line-height:18px; margin:0 0 0;">&copy;<strong> <a href="https://www.thrickodithanamscb.in/" >www.thrickodithanamscb.in</a></strong> </p>
</td>
</tr>
<tr>
<td style="height:80px;">&nbsp;</td>
</tr>
</table>
</td>
</tr>
</table>
<!--/100% body table-->
</body>
</html> `;
subject = 'Payment Confirmation - Tender Document Download Available'
}
await this.mailService.sendMail(email, subject, content, content); await this.mailService.sendMail(email, subject, content, content);
} }
async sendOtp(body: { email: string, custName: string, tenderName: string, bidOpenDate: string }, flag: string): Promise<void> { async sendOtp(body: { email: string, custName: string, tenderName?: string, bidOpenDate?: string }, flag: string): Promise<void> {
if (body.email) { if (body.email) {
if (flag == 'F' || flag == 'R' || flag == 'UD') { if (flag == 'F' || flag == 'R' || flag == 'UD' || flag == 'CP') {
let isUserExist = await this.pcduserRepository.findOne({ where: { email: body.email } }); let isUserExist = await this.pcduserRepository.findOne({ where: { email: body.email } });
@ -427,6 +518,9 @@ export class AuthService {
if (body.email && flag == 'UD') { if (body.email && flag == 'UD') {
await this.sendMail(body.email, body.custName, body.tenderName, body.bidOpenDate, newOtp, 'uDocSub'); await this.sendMail(body.email, body.custName, body.tenderName, body.bidOpenDate, newOtp, 'uDocSub');
} }
if (body.email && flag == 'CP') {
await this.sendMail(body.email, body.custName, body.tenderName, body.bidOpenDate, newOtp, 'confP');
}
} }

@ -4,6 +4,7 @@ import {Pcduser} from "src/auth/pcduser.entity";
export const GetUser = createParamDecorator( export const GetUser = createParamDecorator(
(data: unknown, ctx: ExecutionContext):Pcduser => { (data: unknown, ctx: ExecutionContext):Pcduser => {
const request = ctx.switchToHttp().getRequest(); const request = ctx.switchToHttp().getRequest();
return request.user; return request.user;
}, },
); );

@ -3,9 +3,10 @@ import { Strategy, ExtractJwt } from 'passport-jwt';
import { Injectable, UnauthorizedException, Logger, Inject, Scope } from '@nestjs/common'; import { Injectable, UnauthorizedException, Logger, Inject, Scope } from '@nestjs/common';
import { JwtPayload } from './jwt-payload.interface'; import { JwtPayload } from './jwt-payload.interface';
import * as config from 'config'; import * as config from 'config';
import { getConnection } from 'typeorm'; import { DataSource, getConnection } from 'typeorm';
import { PcduserRepository } from './pcduser.repository'; import { PcduserRepository } from './pcduser.repository';
import { PcduserDto } from 'src/auth/dto/pcd-user.dto'; import { PcduserDto } from 'src/auth/dto/pcd-user.dto';
import { InjectRepository } from '@nestjs/typeorm';
@Injectable() @Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) { export class JwtStrategy extends PassportStrategy(Strategy) {
@ -13,6 +14,8 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
private logger = new Logger('Jwt Strategy'); // for logging private logger = new Logger('Jwt Strategy'); // for logging
constructor( constructor(
@InjectRepository(PcduserRepository)
private pcduserRepository: PcduserRepository,
) { ) {
super({ super({
jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(), jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
@ -25,9 +28,9 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
const { userId, userName, emailId, module } = payload; const { userId, userName, emailId, module } = payload;
this.logger.log(`Payload ${JSON.stringify(payload)}`); this.logger.log(`Payload ${JSON.stringify(payload)}`);
let connect = getConnection(); let connect = DataSource;
const repo = await connect.getCustomRepository(PcduserRepository); const repo = this.pcduserRepository;
const user:PcduserDto = await repo.findOne(userId); const user:PcduserDto = await repo.findOne({where:{userId:userId}});
delete user.pass; delete user.pass;
delete user.salt; delete user.salt;
if (!user) { if (!user) {

@ -1,10 +1,13 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, Repository } from "typeorm";
import { Logger } from "@nestjs/common"; import { Injectable, Logger } from "@nestjs/common";
import { Pcdotp } from "./pcdotp.entity"; import { Pcdotp } from "./pcdotp.entity";
import * as config from 'config'; import * as config from 'config';
@EntityRepository(Pcdotp) @Injectable()
export class PcdotpRepository extends Repository<Pcdotp>{ export class PcdotpRepository extends Repository<Pcdotp>{
constructor(private dataSource: DataSource) {
super(Pcdotp, dataSource.createEntityManager());
}
private logger = new Logger('PcdotpRepository'); // for logging private logger = new Logger('PcdotpRepository'); // for logging

@ -1,16 +1,19 @@
import { BadRequestException, Logger } from "@nestjs/common"; import { BadRequestException, Injectable, Logger } from "@nestjs/common";
import { EntityRepository, ILike, Like, Repository } from "typeorm"; import { DataSource, ILike, Like, Repository } from "typeorm";
import { TempSignUpDto } from "./dto/temp-sign-up.dto"; import { TempSignUpDto } from "./dto/temp-sign-up.dto";
import { Pcduser } from "./pcduser.entity"; import { Pcduser } from "./pcduser.entity";
import * as bcrypt from 'bcrypt'; import * as bcrypt from 'bcrypt';
import { AuthCreadentialsDto } from "./dto/auth-credentials.dto"; import { AuthCreadentialsDto } from "./dto/auth-credentials.dto";
import { PcduserDto } from "src/auth/dto/pcd-user.dto"; import { PcduserDto } from "src/auth/dto/pcd-user.dto";
@EntityRepository(Pcduser) @Injectable()
export class PcduserRepository extends Repository<Pcduser>{ export class PcduserRepository extends Repository<Pcduser>{
constructor(private dataSource: DataSource) {
super(Pcduser, dataSource.createEntityManager());
}
private logger = new Logger('Pcduser Repo'); // for logging private logger = new Logger('Pcduser Repo'); // for logging
async updateRefreshToken(userId: string, refreshToken: string) { async updateRefreshToken(userId: string, refreshToken: string) {
const user = await this.findOne({ userId: userId }); const user = await this.findOne({where:{ userId: userId }});
user.refreshtoken = refreshToken; user.refreshtoken = refreshToken;
this.save(user); this.save(user);
} }

@ -11,7 +11,7 @@ export const typeOrmConfig: TypeOrmModuleOptions = {
password:'inv123', password:'inv123',
database:'scb-tender', database:'scb-tender',
entities: [__dirname + '/../**/*.entity.{js,ts}'], entities: [__dirname + '/../**/*.entity.{js,ts}'],
synchronize:true, synchronize:false,
logging:false logging:false
}; };

@ -0,0 +1,3 @@
export class CommonDto{
marquee : string
}

@ -9,4 +9,8 @@ export class PaymentMasterDto {
status?:string status?:string
finalBidAmt?:number finalBidAmt?:number
notificationViewed?:string
message?:string
} }

@ -0,0 +1,11 @@
export class reportAuthenticationDto{
id:number;
adminUsers:string
key:number[]
}

@ -41,7 +41,7 @@ export function createFolders(filePath: string) {
export class FileUploadController { export class FileUploadController {
constructor( constructor(
@InjectRepository(tenderDocRepository) @InjectRepository(tenderDocRepository)
private tenderDocRepository:tenderDocRepository, private readonly tenderDocRepository:tenderDocRepository,
private iservice: FileUploadService, private iservice: FileUploadService,
) { ) {
@ -140,7 +140,7 @@ export class FileUploadController {
await fs.promises.unlink(filePath); await fs.promises.unlink(filePath);
const filter = { docName: filename ,id:id }; const filter = { docName: filename ,id:id };
const deletedEntry = await this.tenderDocRepository.findOne({where:{ docName: filename ,tenderId:id , documentCategory:'D'}}); const deletedEntry = await this.tenderDocRepository.findOne({where:{ docName: filename ,tenderId:parseInt(id) , documentCategory:'D'}});
if (deletedEntry) { if (deletedEntry) {
console.log('helloooooo'); console.log('helloooooo');
await this.tenderDocRepository.remove(deletedEntry); await this.tenderDocRepository.remove(deletedEntry);
@ -166,7 +166,7 @@ async deleteUserDoc(
await fs.promises.unlink(filePath); await fs.promises.unlink(filePath);
const filter = { docName: filename }; const filter = { docName: filename };
const deletedEntry = await this.tenderDocRepository.findOne({where:{docName : filename , tenderId:id ,userId:userId,documentCategory:'USERD'}}); const deletedEntry = await this.tenderDocRepository.findOne({where:{docName : filename , tenderId:parseInt(id) ,userId:parseInt(userId),documentCategory:'USERD'}});
if (deletedEntry) { if (deletedEntry) {
console.log('helloooooo'); console.log('helloooooo');
await this.tenderDocRepository.remove(deletedEntry); await this.tenderDocRepository.remove(deletedEntry);
@ -190,7 +190,7 @@ async deleteBankDoc(
await fs.promises.unlink(filePath); await fs.promises.unlink(filePath);
const filter = { docName: filename }; const filter = { docName: filename };
const deletedEntry = await this.tenderDocRepository.findOne({where:{docName: filename , tenderId:id , documentCategory:'WID'}}); const deletedEntry = await this.tenderDocRepository.findOne({where:{docName: filename , tenderId:parseInt(id) , documentCategory:'WID'}});
if (deletedEntry) { if (deletedEntry) {
console.log('helloooooo'); console.log('helloooooo');
await this.tenderDocRepository.remove(deletedEntry); await this.tenderDocRepository.remove(deletedEntry);
@ -215,7 +215,7 @@ async deleteNotice(
await fs.promises.unlink(filePath); await fs.promises.unlink(filePath);
const filter = { docName: filename }; const filter = { docName: filename };
const deletedEntry = await this.tenderDocRepository.findOne({where:{docName: filename , tenderId:id ,documentCategory:'NIT'}}); const deletedEntry = await this.tenderDocRepository.findOne({where:{docName: filename , tenderId:parseInt(id) ,documentCategory:'NIT'}});
if (deletedEntry) { if (deletedEntry) {
console.log('helloooooo'); console.log('helloooooo');
await this.tenderDocRepository.remove(deletedEntry); await this.tenderDocRepository.remove(deletedEntry);

@ -5,6 +5,7 @@ import { MulterModule } from '@nestjs/platform-express';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { tenderDocRepository } from 'src/tables/tender-documents/tender-doc.repository'; import { tenderDocRepository } from 'src/tables/tender-documents/tender-doc.repository';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { TenderDoc } from 'src/tables/tender-documents/tender-doc.entity';
@Module({ @Module({
imports: [ imports: [
@ -12,13 +13,12 @@ import { TypeOrmModule } from '@nestjs/typeorm';
dest: './uploads' dest: './uploads'
}), }),
TypeOrmModule.forFeature([ TypeOrmModule.forFeature([
tenderDocRepository TenderDoc
]), ]),
AuthModule, AuthModule,
tenderDocRepository
], ],
controllers: [FileUploadController], controllers: [FileUploadController],
providers: [FileUploadService, providers: [FileUploadService,tenderDocRepository
] ]
}) })
export class FileUploadModule { } export class FileUploadModule { }

@ -2,10 +2,6 @@ import { BadRequestException, ConflictException, HttpException, InternalServerEr
import { PcduserDto } from 'src/auth/dto/pcd-user.dto'; import { PcduserDto } from 'src/auth/dto/pcd-user.dto';
import { FindManyOptions, Not, Repository } from 'typeorm'; import { FindManyOptions, Not, Repository } from 'typeorm';
import { PcdFormGridInterface } from '../interface/pcd-form-grid.interface'; import { PcdFormGridInterface } from '../interface/pcd-form-grid.interface';
import * as config from 'config'
import { log } from 'console';
const oracledb = require('oracledb');
const dbConfig = config.get('db');
export class PcdFormGridService<T> implements PcdFormGridInterface { export class PcdFormGridService<T> implements PcdFormGridInterface {
@ -124,10 +120,6 @@ export class PcdFormGridService<T> implements PcdFormGridInterface {
return true; return true;
} }
async updateOne(body: any, id: string | number, user: PcduserDto): Promise<any> { async updateOne(body: any, id: string | number, user: PcduserDto): Promise<any> {
console.log("====user====", user);
console.log(id);
console.log(body);
for (let colMan of this.MANDATORY_FEILDS) { for (let colMan of this.MANDATORY_FEILDS) {

@ -1,5 +1,5 @@
import { PcdtTransactionInterface } from "../interface/pcd-transaction.interface"; import { PcdtTransactionInterface } from "../interface/pcd-transaction.interface";
import { FindManyOptions, Repository, getConnection, QueryRunner, Connection } from "typeorm"; import { FindManyOptions, Repository, getConnection, QueryRunner, Connection, DataSource, FindOneOptions } from "typeorm";
import { BadRequestException, NotAcceptableException, UnauthorizedException, InternalServerErrorException, MethodNotAllowedException, HttpException, Inject } from "@nestjs/common"; import { BadRequestException, NotAcceptableException, UnauthorizedException, InternalServerErrorException, MethodNotAllowedException, HttpException, Inject } from "@nestjs/common";
import { TransactionDetailDto } from "src/framework/custom/transaction-detail.dto"; import { TransactionDetailDto } from "src/framework/custom/transaction-detail.dto";
import { PcduserDto } from "src/auth/dto/pcd-user.dto"; import { PcduserDto } from "src/auth/dto/pcd-user.dto";
@ -16,7 +16,7 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
DETAIL_DATA_FORMAT: TransactionDetailDto[] = []; DETAIL_DATA_FORMAT: TransactionDetailDto[] = [];
constructor( constructor(
private connection: Connection, private connection: DataSource,
private repo: Repository<any> private repo: Repository<any>
) { } ) { }
@ -45,7 +45,7 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
return true return true
} }
async findOne(filter: FindManyOptions, id: string | number,): Promise<T> { async findOne(filter: FindOneOptions, id: string | number,): Promise<T> {
if (!filter.where) filter.where = {}; if (!filter.where) filter.where = {};
if (this.TXN_TYPE) filter.where[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE; if (this.TXN_TYPE) filter.where[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
let orgFilter = Object.create(filter); let orgFilter = Object.create(filter);
@ -55,6 +55,8 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
if (!await this.preFindOne(filter)) if (!await this.preFindOne(filter))
throw new BadRequestException(`Unepected Error Occured in findOne`); throw new BadRequestException(`Unepected Error Occured in findOne`);
//branch right check(); //branch right check();
let result: T = await this.repo.findOne(filter); let result: T = await this.repo.findOne(filter);
if (!result) if (!result)

@ -3,7 +3,6 @@ import { AppModule } from './app.module';
import * as config from 'config'; import * as config from 'config';
import { Logger } from '@nestjs/common'; import { Logger } from '@nestjs/common';
import * as bodyParser from 'body-parser'; import * as bodyParser from 'body-parser';
import { Cluster } from '../cluster';
async function bootstrap() { async function bootstrap() {

@ -85,7 +85,7 @@ export class PaymentGatewayController {
console.log(paymentSuccessBody); console.log(paymentSuccessBody);
const userId = paymentSuccessBody.lastname.split('ESC')[1]; const userId = paymentSuccessBody.lastname.split('ESC')[1];
const tenderId = paymentSuccessBody.lastname.split('ESC')[0]; const tenderId = paymentSuccessBody.lastname.split('ESC')[0];
let user = await this.paymentMasterRepo.findOne({ userId: userId , tenderId:tenderId}); let user = await this.paymentMasterRepo.findOne({where:{ userId: userId , tenderId:tenderId}});
console.log(user); console.log(user);
this.paymentGatewayService.paymentSuccess(paymentSuccessBody, (error, result) => { this.paymentGatewayService.paymentSuccess(paymentSuccessBody, (error, result) => {
@ -126,7 +126,7 @@ export class PaymentGatewayController {
const paymentFailureBody = req.body; const paymentFailureBody = req.body;
const userId = paymentFailureBody.lastname.split('ESC')[1]; const userId = paymentFailureBody.lastname.split('ESC')[1];
const tenderId = paymentFailureBody.lastname.split('ESC')[0]; const tenderId = paymentFailureBody.lastname.split('ESC')[0];
let user = await this.paymentMasterRepo.findOne({ userId: userId , tenderId:tenderId}); let user = await this.paymentMasterRepo.findOne({where:{ userId: userId , tenderId:tenderId}});
console.log(user); console.log(user);
this.paymentGatewayService.paymentFailure(paymentFailureBody, (error, result) => { this.paymentGatewayService.paymentFailure(paymentFailureBody, (error, result) => {
console.log(paymentFailureBody); console.log(paymentFailureBody);

@ -1,4 +1,4 @@
import { HttpModule, Module } from '@nestjs/common'; import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { AuthService } from 'src/auth/auth.service'; import { AuthService } from 'src/auth/auth.service';
@ -6,8 +6,7 @@ import { CryptoService } from 'src/auth/crypto.service';
import { PcduserRepository } from 'src/auth/pcduser.repository'; import { PcduserRepository } from 'src/auth/pcduser.repository';
import { EmailModule } from 'src/email/email.module'; import { EmailModule } from 'src/email/email.module';
import { PaymentStatusRepository } from 'src/tables/payment-status/payment-status.repository'; import { PaymentStatusRepository } from 'src/tables/payment-status/payment-status.repository';
import { HttpModule } from '@nestjs/axios';
import { PaymentGatewayController } from './payment-gateway.controller'; import { PaymentGatewayController } from './payment-gateway.controller';
import { PaymentGatewayService } from './payment-gateway.service'; import { PaymentGatewayService } from './payment-gateway.service';

@ -1,4 +1,4 @@
import { BadRequestException, HttpException, HttpService, Injectable, InternalServerErrorException, Logger, MethodNotAllowedException } from '@nestjs/common'; import { BadRequestException, HttpException, Injectable, InternalServerErrorException, Logger, MethodNotAllowedException } from '@nestjs/common';
import { PaymentDto } from '../dto/payment.dto'; import { PaymentDto } from '../dto/payment.dto';
import { AuthService } from 'src/auth/auth.service'; import { AuthService } from 'src/auth/auth.service';
import { Connection, FindManyOptions, getConnection } from 'typeorm'; import { Connection, FindManyOptions, getConnection } from 'typeorm';
@ -13,15 +13,16 @@ import { PurchaseDto } from 'src/dto/purchase.dto';
import { PaymentStatusDto } from 'src/dto/payment-status.dto'; import { PaymentStatusDto } from 'src/dto/payment-status.dto';
import { convertDate } from 'src/pipe/pcd-date.pipe'; import { convertDate } from 'src/pipe/pcd-date.pipe';
var crypto = require('crypto') var crypto = require('crypto')
import fetch from "node-fetch";
import { PayuTransactionListDto } from 'src/dto/payu-transaction-list.dto'; import { PayuTransactionListDto } from 'src/dto/payu-transaction-list.dto';
import { PayuTransactionListRepository } from 'src/tables/payu-transaction-list/payu-transaction-list.repository'; import { PayuTransactionListRepository } from 'src/tables/payu-transaction-list/payu-transaction-list.repository';
import { PcduserDto } from 'src/auth/dto/pcd-user.dto'; import { PcduserDto } from 'src/auth/dto/pcd-user.dto';
import { PaymentMasterDto } from 'src/dto/payment-master.dto'; import { PaymentMasterDto } from 'src/dto/payment-master.dto';
import { Console } from 'console'; import { Console } from 'console';
import { PaymentMasterRepository } from 'src/tables/payment-master/payment-master.repository'; import { PaymentMasterRepository } from 'src/tables/payment-master/payment-master.repository';
import { HttpService } from '@nestjs/axios';
var myHeaders = new fetch.Headers();
const payUMoney = require("payumoney_nodejs"); const payUMoney = require("payumoney_nodejs");
const querystring = require('querystring'); const querystring = require('querystring');

@ -0,0 +1,16 @@
import { Controller } from '@nestjs/common';
import { CommonDto } from 'src/dto/common.dto';
import { PcdFormGridController } from 'src/framework/beans/pcd-form-grid.controller';
import { CommonService } from './common.service';
@Controller('common')
export class CommonController extends PcdFormGridController<CommonDto>{
constructor(
private commonService: CommonService
) {
super(commonService);
}
}

@ -0,0 +1,21 @@
import { PcdBaseEntity } from "src/framework/custom/pcd-entity.custom";
import { Column, Entity, EntityRepository, PrimaryGeneratedColumn } from "typeorm";
@Entity('common')
export class Common extends PcdBaseEntity{
@PrimaryGeneratedColumn({
name:"id"
})
id:number
@Column({
name:'marquee',
type:"varchar",
length:1000,
nullable:true
})
marquee:string
}

@ -0,0 +1,15 @@
import { Module } from '@nestjs/common';
import { CommonController } from './common.controller';
import { CommonService } from './common.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { commonRepository } from './common.repository';
import { Common } from './common.entity';
@Module({
imports: [
TypeOrmModule.forFeature([Common]),
],
controllers: [CommonController],
providers: [CommonService,commonRepository]
})
export class CommonModule {}

@ -0,0 +1,12 @@
import { DataSource, Repository } from "typeorm";
import { Common } from "./common.entity";
import { Injectable } from "@nestjs/common";
@Injectable()
export class commonRepository extends Repository<Common>{
constructor(
private datasource:DataSource
){
super(Common,datasource.createEntityManager());
}
}

@ -0,0 +1,18 @@
import { Injectable } from '@nestjs/common';
import { PcdFormGridService } from 'src/framework/beans/pcd-form-grid.service';
import { Common } from './common.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { commonRepository } from './common.repository';
@Injectable()
export class CommonService extends PcdFormGridService<Common>{
constructor(
@InjectRepository(commonRepository)
private commonRepository: commonRepository,
) {
super(commonRepository);
}
}

@ -4,12 +4,13 @@ import { CoversLovService } from './covers-lov.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { CoversLovRepository } from './covers-lov.repository'; import { CoversLovRepository } from './covers-lov.repository';
import { CoversLov } from './covers-lov.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([CoversLovRepository]), TypeOrmModule.forFeature([CoversLov]),
], ],
controllers: [CoversLovController], controllers: [CoversLovController],
providers: [CoversLovService] providers: [CoversLovService,CoversLovRepository]
}) })
export class CoversLovModule {} export class CoversLovModule {}

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, EntityRepository, Repository } from "typeorm";
import { CoversLov } from "./covers-lov.entity"; import { CoversLov } from "./covers-lov.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(CoversLov) @Injectable()
export class CoversLovRepository extends Repository<CoversLov>{ export class CoversLovRepository extends Repository<CoversLov>{
constructor(
private datasource:DataSource
){
super(CoversLov ,datasource.createEntityManager());
}
} }

@ -4,13 +4,14 @@ import { CoversMasterController } from './covers-master.controller';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { CoverMasterRepository } from './covers-master.repository'; import { CoverMasterRepository } from './covers-master.repository';
import { CoverDoc } from './covers-master.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([CoverMasterRepository]), TypeOrmModule.forFeature([CoverDoc]),
AuthModule AuthModule
], ],
providers: [CoversMasterService], providers: [CoversMasterService,CoverMasterRepository],
controllers: [CoversMasterController] controllers: [CoversMasterController]
}) })
export class CoversMasterModule {} export class CoversMasterModule {}

@ -1,7 +1,11 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, Repository } from "typeorm";
import { CoverDoc } from "./covers-master.entity"; import { CoverDoc } from "./covers-master.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(CoverDoc)
export class CoverMasterRepository extends Repository<CoverDoc>{
@Injectable()
export class CoverMasterRepository extends Repository<CoverDoc>{
constructor(private datasource : DataSource){
super(CoverDoc, datasource.createEntityManager());
}
} }

@ -4,13 +4,14 @@ import { DocumentTypeService } from './document-type.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { DocumentTypeRepository } from './document-type.repository'; import { DocumentTypeRepository } from './document-type.repository';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { DocumentType } from './document-type.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([DocumentTypeRepository]), TypeOrmModule.forFeature([DocumentType]),
AuthModule AuthModule
], ],
controllers: [DocumentTypeController], controllers: [DocumentTypeController],
providers: [DocumentTypeService] providers: [DocumentTypeService,DocumentTypeRepository]
}) })
export class DocumentTypeModule {} export class DocumentTypeModule {}

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, EntityRepository, Repository } from "typeorm";
import { DocumentType } from "./document-type.entity"; import { DocumentType } from "./document-type.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(DocumentType) @Injectable()
export class DocumentTypeRepository extends Repository<DocumentType>{ export class DocumentTypeRepository extends Repository<DocumentType>{
constructor(
private datasource : DataSource
){
super(DocumentType,datasource.createEntityManager());
}
} }

@ -4,13 +4,14 @@ import { EmdFeeTypeService } from './emd-fee-type.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { EmdFeeTypeRepository } from './emd-fee-type.repository'; import { EmdFeeTypeRepository } from './emd-fee-type.repository';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { EmdFeeType } from './emd-fee-type.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([EmdFeeTypeRepository]), TypeOrmModule.forFeature([EmdFeeType]),
AuthModule AuthModule
], ],
controllers: [EmdFeeTypeController], controllers: [EmdFeeTypeController],
providers: [EmdFeeTypeService] providers: [EmdFeeTypeService,EmdFeeTypeRepository]
}) })
export class EmdFeeTypeModule {} export class EmdFeeTypeModule {}

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, EntityRepository, Repository } from "typeorm";
import { EmdFeeType } from "./emd-fee-type.entity"; import { EmdFeeType } from "./emd-fee-type.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(EmdFeeType) @Injectable()
export class EmdFeeTypeRepository extends Repository<EmdFeeType>{ export class EmdFeeTypeRepository extends Repository<EmdFeeType>{
constructor(
private datasource : DataSource
){
super(EmdFeeType , datasource.createEntityManager());
}
} }

@ -4,13 +4,14 @@ import { FileFormatLovController } from './file-format-lov.controller';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { FileFormatRepository } from './file-format-lov.repository'; import { FileFormatRepository } from './file-format-lov.repository';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { FileFormat } from './file-format-lov.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([FileFormatRepository]), TypeOrmModule.forFeature([FileFormat]),
], ],
providers: [FileFormatLovService], providers: [FileFormatLovService,FileFormatRepository],
controllers: [FileFormatLovController] controllers: [FileFormatLovController]
}) })
export class FileFormatLovModule {} export class FileFormatLovModule {}

@ -1,7 +1,13 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, Repository } from "typeorm";
import { FileFormat } from "./file-format-lov.entity"; import { FileFormat } from "./file-format-lov.entity";
import { Inject, Injectable } from "@nestjs/common";
@EntityRepository(FileFormat) @Injectable()
export class FileFormatRepository extends Repository<FileFormat>{ export class FileFormatRepository extends Repository<FileFormat>{
constructor(
private datasource : DataSource
){
super(FileFormat , datasource.createEntityManager())
}
} }

@ -4,13 +4,14 @@ import { FormOfContractService } from './form-of-contract.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { FormOfContractRepository } from './form-of-contract.repository'; import { FormOfContractRepository } from './form-of-contract.repository';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { FormOfContract } from './form-of-contract.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([FormOfContractRepository]), TypeOrmModule.forFeature([FormOfContract]),
AuthModule AuthModule
], ],
controllers: [FormOfContractController], controllers: [FormOfContractController],
providers: [FormOfContractService] providers: [FormOfContractService,FormOfContractRepository]
}) })
export class FormOfContractModule {} export class FormOfContractModule {}

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, Repository } from "typeorm";
import { FormOfContract } from "./form-of-contract.entity"; import { FormOfContract } from "./form-of-contract.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(FormOfContract) @Injectable()
export class FormOfContractRepository extends Repository<FormOfContract>{ export class FormOfContractRepository extends Repository<FormOfContract>{
constructor(
private datasource : DataSource
){
super(FormOfContract , datasource.createEntityManager())
}
} }

@ -1,30 +0,0 @@
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";
@Entity('payment-instrument')
export class paymentInstrument extends PcdBaseEntity{
@PrimaryColumn({
name:"id"
})
id:number
@Column({
name:"bank_name",
type:"varchar",
nullable:true
})
bankName:string
@Column({
name:"tender_id",
type:"numeric",
//length:500,
nullable:true
})
tenderId:number
@ManyToOne(() => TenderMaster,(tenderMaster)=> tenderMaster.coverDoc)
@JoinColumn([{ name: "tender_id", referencedColumnName: "id" }])
tenderIdD:TenderMaster
}

@ -1,7 +0,0 @@
import { EntityRepository, Repository } from "typeorm";
import { paymentInstrument } from "./payment-ins.entity";
@EntityRepository(paymentInstrument)
export class paymentInstrumentRepository extends Repository<paymentInstrument>{
}

@ -21,7 +21,6 @@ export class PaymentMasterController extends PcdFormGridController<PaymentMaster
return this.paymentMasterService.bidReport(tenderId) return this.paymentMasterService.bidReport(tenderId)
} }
@Get('bid-payment-check/:userId/:tenderId') @Get('bid-payment-check/:userId/:tenderId')
async bidPaymentCheck( async bidPaymentCheck(
@Param('userId') userId: string, @Param('userId') userId: string,
@ -63,5 +62,11 @@ export class PaymentMasterController extends PcdFormGridController<PaymentMaster
return this.paymentMasterService.AdminUpdatePaymentStatus(userId,tenderId,body) return this.paymentMasterService.AdminUpdatePaymentStatus(userId,tenderId,body)
} }
@Get('notifications/:id')
async notificationMsg(
@Param('id') userId: string
){
return this.paymentMasterService.notificationMsg(userId)
}
} }

@ -46,6 +46,23 @@ export class PaymentMaster extends PcdBaseEntity{
}) })
finalBidAmt:number finalBidAmt:number
@Column({
name:'notification_viewed',
type:"varchar",
length:1,
nullable:true
})
notificationViewed:string
@Column({
name:"message",
type:"varchar",
length:2000,
nullable : true
})
message:string
@ManyToOne(() => Pcduser, (pcduser) => pcduser.paymentMaster, { eager: true }) @ManyToOne(() => Pcduser, (pcduser) => pcduser.paymentMaster, { eager: true })
@JoinColumn([{ name: "user_id", referencedColumnName: "userId" }]) @JoinColumn([{ name: "user_id", referencedColumnName: "userId" }])

@ -4,13 +4,14 @@ import { PaymentMasterService } from './payment-master.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { PaymentMasterRepository } from './payment-master.repository'; import { PaymentMasterRepository } from './payment-master.repository';
import { PaymentMaster } from './payment-master.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([PaymentMasterRepository]), TypeOrmModule.forFeature([PaymentMaster]),
AuthModule AuthModule
], ],
controllers: [PaymentMasterController], controllers: [PaymentMasterController],
providers: [PaymentMasterService] providers: [PaymentMasterService,PaymentMasterRepository]
}) })
export class PaymentMasterModule {} export class PaymentMasterModule {}

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, Repository } from "typeorm";
import { PaymentMaster } from "./payment-master.entity"; import { PaymentMaster } from "./payment-master.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(PaymentMaster) @Injectable()
export class PaymentMasterRepository extends Repository<PaymentMaster>{ export class PaymentMasterRepository extends Repository<PaymentMaster>{
constructor(
private datasource : DataSource
){
super(PaymentMaster , datasource.createEntityManager());
}
} }

@ -49,7 +49,7 @@ async bidPaymentCheck(tenderId,userId){
} }
async finalBidAmt(tenderId ,userId,body){ async finalBidAmt(tenderId ,userId,body){
let user = await this.paymentMasterRepository.findOne({ tenderId:tenderId , userId:userId }); let user = await this.paymentMasterRepository.findOne({where:{ tenderId:tenderId , userId:userId }});
if(!user){ if(!user){
throw new BadRequestException('User Details not found') throw new BadRequestException('User Details not found')
} }
@ -91,18 +91,37 @@ async paymentInfo(paymentMasterDto) {
async AdminUpdatePaymentStatus(userId , tenderId , body){ async AdminUpdatePaymentStatus(userId , tenderId , body){
try{ try{
let user =await this.paymentMasterRepository.findOne({userId:userId , tenderId:tenderId}) let user =await this.paymentMasterRepository.findOne({where:{userId:userId , tenderId:tenderId}})
console.log(user); console.log(user);
user.status = body.status; user.status = body.status;
user.message = body.message;
user.notificationViewed= body.notificationViewed;
let result = await this.paymentMasterRepository.save(user); let result = await this.paymentMasterRepository.save(user);
return {data: "Payment Status Updated Successfully" } return {data: "Payment Status Updated Successfully" }
}catch(err){ }catch(err){
console.log(err);
return {data: "Error in Payment Status Updation" } return {data: "Error in Payment Status Updation" }
} }
} }
async notificationMsg(id){
let query = `SELECT status , message ,tm.title "title"
FROM "payment-master" pm
LEFT JOIN tender_master tm ON tm.id = pm.tender_id
WHERE user_id = '${id}'
AND notification_viewed = 'N';`
let users = await this.paymentMasterRepository.query(query);
this.paymentMasterRepository.update({notificationViewed:"N",userId:id},{notificationViewed:"Y"})
return users
}
} }

@ -4,13 +4,14 @@ import { PaymentModeService } from './payment-mode.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { PaymentModeRepository } from './payment-mode.repository'; import { PaymentModeRepository } from './payment-mode.repository';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { PaymentMode } from './payment-mode.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([PaymentModeRepository]), TypeOrmModule.forFeature([PaymentMode]),
AuthModule AuthModule
], ],
controllers: [PaymentModeController], controllers: [PaymentModeController],
providers: [PaymentModeService] providers: [PaymentModeService,PaymentModeRepository]
}) })
export class PaymentModeModule {} export class PaymentModeModule {}

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, Repository } from "typeorm";
import { PaymentMode } from "./payment-mode.entity"; import { PaymentMode } from "./payment-mode.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(PaymentMode) @Injectable()
export class PaymentModeRepository extends Repository<PaymentMode>{ export class PaymentModeRepository extends Repository<PaymentMode>{
constructor(
private dataSource:DataSource
){
super(PaymentMode,dataSource.createEntityManager());
}
} }

@ -4,15 +4,16 @@ import { AuthModule } from 'src/auth/auth.module';
import { PaymentStatusController } from './payment-status.controller'; import { PaymentStatusController } from './payment-status.controller';
import { PaymentStatusRepository } from './payment-status.repository'; import { PaymentStatusRepository } from './payment-status.repository';
import { PaymentStatusService } from './payment-status.service'; import { PaymentStatusService } from './payment-status.service';
import { PaymentStatus } from './payment-status.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([ TypeOrmModule.forFeature([
PaymentStatusRepository PaymentStatus
]), ]),
AuthModule AuthModule
], ],
controllers: [PaymentStatusController], controllers: [PaymentStatusController],
providers: [PaymentStatusService] providers: [PaymentStatusService,PaymentStatusRepository]
}) })
export class PaymentStatusModule { } export class PaymentStatusModule { }

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, Repository } from "typeorm";
import { PaymentStatus } from "./payment-status.entity"; import { PaymentStatus } from "./payment-status.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(PaymentStatus) @Injectable()
export class PaymentStatusRepository extends Repository<PaymentStatus>{ export class PaymentStatusRepository extends Repository<PaymentStatus>{
constructor(
private datasource : DataSource
){
super(PaymentStatus,datasource.createEntityManager());
}
} }

@ -1,20 +1,21 @@
import { HttpModule, Module } from '@nestjs/common'; import { Module } from '@nestjs/common';
import { PayuTransactionListService } from './payu-transaction-list.service'; import { PayuTransactionListService } from './payu-transaction-list.service';
import { PayuTransactionListController } from './payu-transaction-list.controller'; import { PayuTransactionListController } from './payu-transaction-list.controller';
import { PayuTransactionListRepository } from './payu-transaction-list.repository'; import { PayuTransactionListRepository } from './payu-transaction-list.repository';
import { PcduserRepository } from 'src/auth/pcduser.repository'; import { PcduserRepository } from 'src/auth/pcduser.repository';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { HttpModule} from '@nestjs/axios';
import { PayuTransactionListEntity } from './payu-transaction-list.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([ TypeOrmModule.forFeature([
PayuTransactionListRepository, PayuTransactionListEntity
]), ]),
AuthModule, AuthModule,
HttpModule HttpModule
], ],
providers: [PayuTransactionListService], providers: [PayuTransactionListService,PayuTransactionListRepository],
controllers: [PayuTransactionListController], controllers: [PayuTransactionListController],
exports: [PayuTransactionListService] exports: [PayuTransactionListService]
}) })

@ -1,8 +1,13 @@
import { Logger } from "@nestjs/common"; import { Injectable, Logger } from "@nestjs/common";
import { EntityRepository, Repository } from "typeorm"; import { DataSource, EntityRepository, Repository } from "typeorm";
import { PayuTransactionListEntity } from "./payu-transaction-list.entity"; import { PayuTransactionListEntity } from "./payu-transaction-list.entity";
@EntityRepository(PayuTransactionListEntity) @Injectable()
export class PayuTransactionListRepository extends Repository<PayuTransactionListEntity>{ export class PayuTransactionListRepository extends Repository<PayuTransactionListEntity>{
constructor(
private datasource:DataSource
){
super(PayuTransactionListEntity,datasource.createEntityManager());
}
private logger = new Logger ("SisPayuTransactionListRepository"); private logger = new Logger ("SisPayuTransactionListRepository");
} }

@ -1,4 +1,4 @@
import { Body, HttpService, Injectable } from '@nestjs/common'; import { Body, Injectable } from '@nestjs/common';
import { Cron } from '@nestjs/schedule'; import { Cron } from '@nestjs/schedule';
import { InjectRepository } from '@nestjs/typeorm'; import { InjectRepository } from '@nestjs/typeorm';
import * as config from 'config'; import * as config from 'config';
@ -10,6 +10,7 @@ import { convertDateString } from 'src/pipe/pcd-date.pipe';
import { FindManyOptions, In } from 'typeorm'; import { FindManyOptions, In } from 'typeorm';
import { PayuTransactionListRepository } from './payu-transaction-list.repository'; import { PayuTransactionListRepository } from './payu-transaction-list.repository';
import { sha512 } from 'js-sha512'; import { sha512 } from 'js-sha512';
import { HttpService } from '@nestjs/axios';
@Injectable() @Injectable()

@ -4,13 +4,14 @@ import { ProductCategoryService } from './product-category.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { ProductCategoryRepository } from './product-category.repository'; import { ProductCategoryRepository } from './product-category.repository';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { ProductCategory } from './product-category.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([ProductCategoryRepository]), TypeOrmModule.forFeature([ProductCategory]),
AuthModule AuthModule
], ],
controllers: [ProductCategoryController], controllers: [ProductCategoryController],
providers: [ProductCategoryService] providers: [ProductCategoryService,ProductCategoryRepository]
}) })
export class ProductCategoryModule {} export class ProductCategoryModule {}

@ -1,7 +1,11 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, EntityRepository, Repository } from "typeorm";
import { ProductCategory } from "./product-category.entity"; import { ProductCategory } from "./product-category.entity";
import { Inject, Injectable } from "@nestjs/common";
@EntityRepository(ProductCategory) @Injectable()
export class ProductCategoryRepository extends Repository<ProductCategory>{ export class ProductCategoryRepository extends Repository<ProductCategory>{
constructor(
private datasource : DataSource
){
super(ProductCategory,datasource.createEntityManager());
}
} }

@ -0,0 +1,30 @@
import { Controller, Post, Body, UseInterceptors, UploadedFile, UseGuards } from '@nestjs/common';
import { reportAuthenticationDto } from 'src/dto/report-authentication.dto';
import { PcdFormGridController } from 'src/framework/beans/pcd-form-grid.controller';
import { ReportAuthenticationService } from './report-authentication.service';
import { FileInterceptor } from '@nestjs/platform-express';
import { AuthGuard } from '@nestjs/passport';
@UseGuards(AuthGuard())
@Controller('report-authentication')
export class ReportAuthenticationController extends PcdFormGridController<reportAuthenticationDto> {
constructor(
private reportAuthenticationService: ReportAuthenticationService
) {
super(reportAuthenticationService);
}
@Post('upload-certificate')
@UseInterceptors(FileInterceptor('certificate'))
async uploadCertificate(
@UploadedFile() certificate,
@Body() body: { adminUser: string }
): Promise<any> {
return this.reportAuthenticationService.verifyAdmin(certificate, body.adminUser);
}
}

@ -0,0 +1,26 @@
import { PcdBaseEntity } from "src/framework/custom/pcd-entity.custom";
import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
@Entity('report-authentication')
export class reportAuthenticationEntity extends PcdBaseEntity{
@PrimaryGeneratedColumn({
name:"id"
})
id:number
@Column({
name:'admin_users',
type:"varchar",
length:50,
nullable:true
})
adminUsers:string
@Column({
type: 'json',
nullable: true,
})
key: number[];
}

@ -0,0 +1,17 @@
import { Module } from '@nestjs/common';
import { ReportAuthenticationController } from './report-authentication.controller';
import { ReportAuthenticationService } from './report-authentication.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { reportAuthenticationEntity } from './report-authentication.entity';
import { reportAuthenticationRepository } from './report-authentication.repository';
import { AuthModule } from 'src/auth/auth.module';
@Module({
imports: [
TypeOrmModule.forFeature([reportAuthenticationEntity]),
AuthModule
],
controllers: [ReportAuthenticationController],
providers: [ReportAuthenticationService,reportAuthenticationRepository]
})
export class ReportAuthenticationModule {}

@ -0,0 +1,12 @@
import { DataSource, Repository } from "typeorm";
import { reportAuthenticationEntity } from "./report-authentication.entity";
import { Injectable } from "@nestjs/common";
@Injectable()
export class reportAuthenticationRepository extends Repository<reportAuthenticationEntity>{
constructor(
private datasource : DataSource
){
super(reportAuthenticationEntity,datasource.createEntityManager());
}
}

@ -0,0 +1,59 @@
import { BadRequestException, Injectable, UnauthorizedException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { reportAuthenticationDto } from 'src/dto/report-authentication.dto';
import { PcdFormGridService } from 'src/framework/beans/pcd-form-grid.service';
import { reportAuthenticationRepository } from './report-authentication.repository';
import * as fs from 'fs';
import * as forge from 'node-forge';
@Injectable()
export class ReportAuthenticationService extends PcdFormGridService<reportAuthenticationDto>{
constructor(
@InjectRepository(reportAuthenticationRepository)
private reportAuthenticationRepository: reportAuthenticationRepository,
) {
super(reportAuthenticationRepository);
}
async verifyAdmin(certificate, adminUser) {
const binaryData = certificate.buffer.toString('base64');
const pemCert = `-----BEGIN CERTIFICATE-----\n${binaryData}\n-----END CERTIFICATE-----`;
const cert = forge.pki.certificateFromPem(pemCert);
let validFrom = cert.validity.notBefore
let validTo = cert.validity.notAfter
let date = new Date()
const user = await this.reportAuthenticationRepository.findOne({
where: { id: adminUser }
});
//Uncomment when we want to add a new public key
// console.log(cert.publicKey.n.data);
// user.adminUsers = cert.publicKey.n.data;
// this.reportAuthenticationRepository.save(user);
if (!user) {
throw new BadRequestException('Admin User not found');
}
let certKey = cert.publicKey.n.data.toString()
let userKey = user.key.toString()
if (certKey !== userKey) {
throw new BadRequestException('Key Not Matching. Please Try Again');
}
// else if (validTo < date) {
// throw new UnauthorizedException("Digital Signature Expired")
// }
else {
return { message: 'Authentication Successfully Completed'};
}
}
}

@ -4,13 +4,14 @@ import { TenderCategoryService } from './tender-category.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { TenderCategoryRepository } from './tender-category.repository'; import { TenderCategoryRepository } from './tender-category.repository';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { TenderCategory } from './tender-category.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([TenderCategoryRepository]), TypeOrmModule.forFeature([TenderCategory]),
AuthModule AuthModule
], ],
controllers: [TenderCategoryController], controllers: [TenderCategoryController],
providers: [TenderCategoryService] providers: [TenderCategoryService,TenderCategoryRepository]
}) })
export class TenderCategoryModule {} export class TenderCategoryModule {}

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, EntityRepository, Repository } from "typeorm";
import { TenderCategory } from "./tender-category.entity"; import { TenderCategory } from "./tender-category.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(TenderCategory) @Injectable()
export class TenderCategoryRepository extends Repository<TenderCategory>{ export class TenderCategoryRepository extends Repository<TenderCategory>{
constructor(
private datasource : DataSource
){
super(TenderCategory,datasource.createEntityManager());
}
} }

@ -1,7 +1,9 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, Repository } from "typeorm";
import { TenderDoc } from "./tender-doc.entity"; import { TenderDoc } from "./tender-doc.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(TenderDoc) @Injectable()
export class tenderDocRepository extends Repository<TenderDoc>{ export class tenderDocRepository extends Repository<TenderDoc>{
constructor(private dataSource: DataSource) {
super(TenderDoc, dataSource.createEntityManager());
}
} }

@ -3,6 +3,7 @@ import { TenderDetailsController } from './tender-details.controller';
import { TenderDetailsService } from './tender-details.service'; import { TenderDetailsService } from './tender-details.service';
import { TenderMasterRepository } from './tender-master.repository'; import { TenderMasterRepository } from './tender-master.repository';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { TenderMaster } from './tender-master.entity';
@Module({ @Module({

@ -1,5 +1,4 @@
import { PcdBaseEntity } from "src/framework/custom/pcd-entity.custom"; import { PcdBaseEntity } from "src/framework/custom/pcd-entity.custom";
import { paymentInstrument } from "src/tables/payment-instrument/payment-ins.entity";
import { EmdFeeType } from "src/tables/emd-fee-type/emd-fee-type.entity"; import { EmdFeeType } from "src/tables/emd-fee-type/emd-fee-type.entity";
import { FormOfContract } from "src/tables/form-of-contract/form-of-contract.entity"; import { FormOfContract } from "src/tables/form-of-contract/form-of-contract.entity";
import { PaymentMode } from "src/tables/payment-mode/payment-mode.entity"; import { PaymentMode } from "src/tables/payment-mode/payment-mode.entity";
@ -377,8 +376,8 @@ export class TenderMaster extends PcdBaseEntity {
@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(() => PaymentMaster, (paymentMaster) => paymentMaster.tenderMasterD) @OneToMany(() => PaymentMaster, (paymentMaster) => paymentMaster.tenderMasterD)

@ -1,5 +1,10 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, Repository } from "typeorm";
import { TenderMaster } from "./tender-master.entity"; import { TenderMaster } from "./tender-master.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(TenderMaster) @Injectable()
export class TenderMasterRepository extends Repository<TenderMaster>{} export class TenderMasterRepository extends Repository<TenderMaster>{
constructor(private dataSource: DataSource) {
super(TenderMaster, dataSource.createEntityManager());
}
}

@ -4,13 +4,14 @@ import { TenderTypeService } from './tender-type.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { TenderTypeRepository } from './tender-type.repository'; import { TenderTypeRepository } from './tender-type.repository';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { TenderType } from './tender-type.entity';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([TenderTypeRepository]), TypeOrmModule.forFeature([TenderType]),
AuthModule AuthModule
], ],
controllers: [TenderTypeController], controllers: [TenderTypeController],
providers: [TenderTypeService] providers: [TenderTypeService,TenderTypeRepository]
}) })
export class TenderTypeModule {} export class TenderTypeModule {}

@ -1,6 +1,11 @@
import { EntityRepository, Repository } from "typeorm"; import { DataSource, EntityRepository, Repository } from "typeorm";
import { TenderType } from "./tender-type.entity"; import { TenderType } from "./tender-type.entity";
@EntityRepository(TenderType) import { Injectable } from "@nestjs/common";
@Injectable()
export class TenderTypeRepository extends Repository<TenderType>{ export class TenderTypeRepository extends Repository<TenderType>{
constructor(
private datasource : DataSource
){
super(TenderType,datasource.createEntityManager());
}
} }

@ -1,4 +1,4 @@
import { Body, Controller, Get, UseGuards,Query } from '@nestjs/common'; import { Body, Controller, Get, UseGuards,Query, Post, Param } from '@nestjs/common';
import { TenderDetailDto } from 'src/dto/tender-master.dto'; import { TenderDetailDto } from 'src/dto/tender-master.dto';
import { PcdTransactionController } from 'src/framework/beans/pcd-transaction.controller'; import { PcdTransactionController } from 'src/framework/beans/pcd-transaction.controller';
import { TenderService } from './tender.service'; import { TenderService } from './tender.service';
@ -14,7 +14,7 @@ export class TenderController extends PcdTransactionController<TenderDetailDto>
) { ) {
super(tenderService); super(tenderService);
} }
@UseGuards(AuthGuard())
@Get('admin') @Get('admin')
async getTender( async getTender(
@Query() filter: FindManyOptions, @Query() filter: FindManyOptions,
@ -22,11 +22,21 @@ export class TenderController extends PcdTransactionController<TenderDetailDto>
return this.tenderService.GetAdminTenderD(filter) return this.tenderService.GetAdminTenderD(filter)
} }
@UseGuards(AuthGuard())
@Get('admin/dashboard') @Get('admin/dashboard')
async getDashboard() { async getDashboard() {
return this.tenderService.GetAdminDashboard() return this.tenderService.GetAdminDashboard()
} }
@Post('status/:id')
async CancelTender(
@Param('id') id:string,
@Body() body:{activeYn:string}
) {
return this.tenderService.CancelTender(id,body)
}
} }

@ -4,13 +4,24 @@ import { TenderService } from './tender.service';
import { TypeOrmModule } from '@nestjs/typeorm'; import { TypeOrmModule } from '@nestjs/typeorm';
import { TenderMasterRepository } from 'src/tables/tender-master/tender-master.repository'; import { TenderMasterRepository } from 'src/tables/tender-master/tender-master.repository';
import { AuthModule } from 'src/auth/auth.module'; import { AuthModule } from 'src/auth/auth.module';
import { TenderMaster } from 'src/tables/tender-master/tender-master.entity';
import { TenderDoc } from 'src/tables/tender-documents/tender-doc.entity';
import { CoverDoc } from 'src/tables/covers-master/covers-master.entity';
import { tenderDocRepository } from 'src/tables/tender-documents/tender-doc.repository';
import { CoverMasterRepository } from 'src/tables/covers-master/covers-master.repository';
@Module({ @Module({
imports: [ imports: [
TypeOrmModule.forFeature([TenderMasterRepository]), TypeOrmModule.forFeature([TenderMaster,
TenderDoc,
CoverDoc]),
AuthModule AuthModule
], ],
controllers: [TenderController], controllers: [TenderController],
providers: [TenderService] providers: [TenderService,
TenderMasterRepository,
tenderDocRepository,
CoverMasterRepository
]
}) })
export class TenderModule {} export class TenderModule {}

@ -1,4 +1,4 @@
import { Injectable } from '@nestjs/common'; import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm'; import { InjectRepository } from '@nestjs/typeorm';
import { PcduserDto } from 'src/auth/dto/pcd-user.dto'; import { PcduserDto } from 'src/auth/dto/pcd-user.dto';
import { TenderDetailDto } from 'src/dto/tender-master.dto'; import { TenderDetailDto } from 'src/dto/tender-master.dto';
@ -7,7 +7,7 @@ import { TransactionDetailDto } from 'src/framework/custom/transaction-detail.dt
import { CoverMasterRepository } from 'src/tables/covers-master/covers-master.repository'; import { CoverMasterRepository } from 'src/tables/covers-master/covers-master.repository';
import { tenderDocRepository } from 'src/tables/tender-documents/tender-doc.repository'; import { tenderDocRepository } from 'src/tables/tender-documents/tender-doc.repository';
import { TenderMasterRepository } from 'src/tables/tender-master/tender-master.repository'; import { TenderMasterRepository } from 'src/tables/tender-master/tender-master.repository';
import { Connection, FindManyOptions, LessThanOrEqual, MoreThanOrEqual } from 'typeorm'; import { DataSource, FindManyOptions, LessThanOrEqual, MoreThanOrEqual } from 'typeorm';
@Injectable() @Injectable()
export class TenderService extends PcdTransactionService<TenderDetailDto>{ export class TenderService extends PcdTransactionService<TenderDetailDto>{
@ -15,7 +15,7 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
DETAIL_DATA_FORMAT: TransactionDetailDto[] = [ DETAIL_DATA_FORMAT: TransactionDetailDto[] = [
{ {
detailName: "tenderDoc", repo: this.conn.getCustomRepository(tenderDocRepository), detailName: "tenderDoc", repo: this.tenderDocRepository,
filter: [{ columnName: "tenderId", headerColumn: "id" }], filter: [{ columnName: "tenderId", headerColumn: "id" }],
foreignKeyColumnName: "tenderId", foreignKeyColumnName: "tenderId",
childDetail: [], childDetail: [],
@ -23,7 +23,7 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
orderByColumn: { columnName: "id", sort: "DESC" } orderByColumn: { columnName: "id", sort: "DESC" }
}, },
{ {
detailName: "covers", repo: this.conn.getCustomRepository(CoverMasterRepository), detailName: "covers", repo: this.coverMasterRepository,
filter: [{ columnName: "tenderId", headerColumn: "id" }], filter: [{ columnName: "tenderId", headerColumn: "id" }],
foreignKeyColumnName: "tenderId", foreignKeyColumnName: "tenderId",
childDetail: [], childDetail: [],
@ -32,15 +32,19 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
} }
]; ];
constructor( constructor(
private conn: Connection, private conn: DataSource,
@InjectRepository(TenderMasterRepository) @InjectRepository(TenderMasterRepository)
private tenderMasterRepository: TenderMasterRepository, private tenderMasterRepository: TenderMasterRepository,
@InjectRepository(CoverMasterRepository)
private coverMasterRepository: CoverMasterRepository,
@InjectRepository(tenderDocRepository)
private tenderDocRepository: tenderDocRepository,
) { ) {
super(conn, conn.getCustomRepository(TenderMasterRepository)); super(conn, tenderMasterRepository);
// this.TenderMasterRepository = conn.getCustomRepository(SisPaymentDetailRepository) // this.TenderMasterRepository = conn.getCustomRepository(SisPaymentDetailRepository)
} }
async preFindList(filter: FindManyOptions, user: PcduserDto): Promise<boolean> { async preFindList(filter: FindManyOptions, user: PcduserDto): Promise<any> {
if (!filter.where) filter.where = {}; if (!filter.where) filter.where = {};
if (!user || user.secuLevel == 'U') { if (!user || user.secuLevel == 'U') {
filter.where["publishDate"] = LessThanOrEqual(new Date()); filter.where["publishDate"] = LessThanOrEqual(new Date());
@ -60,4 +64,19 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
let query = `select id, title , bid_open_date as bidOpenDate, publish_date as publishDate from tender_master tm order by id desc` let query = `select id, title , bid_open_date as bidOpenDate, publish_date as publishDate from tender_master tm order by id desc`
return this.tenderMasterRepository.query(query) return this.tenderMasterRepository.query(query)
} }
async CancelTender(id, body) {
let tender = await this.tenderMasterRepository.findOne({ where: { id: id } })
if (tender == null) {
throw new NotFoundException("Tender Details not Found")
}
tender.activeYn = body.activeYn;
this.tenderMasterRepository.save(tender);
if(body.activeYn=='Y'){
return {data:"Tender is Active"}
}else{
return {data:"Tender is Inactive"}
}
} }
}

@ -11,6 +11,6 @@
"outDir": "./dist", "outDir": "./dist",
"baseUrl": "./", "baseUrl": "./",
"incremental": true, "incremental": true,
"resolveJsonModule": true "resolveJsonModule": true,
} }
} }

Loading…
Cancel
Save