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();
}
}
}

41966
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",
"description": "",
"author": "",
@ -22,68 +22,62 @@
},
"dependencies": {
"@nest-modules/mailer": "^1.3.22",
"@nestjs/common": "^7.6.13",
"@nestjs/core": "^7.6.13",
"@nestjs/jwt": "^7.2.0",
"@nestjs/passport": "^7.1.6",
"@nestjs/platform-express": "^7.6.13",
"@nestjs/schedule": "^1.0.1",
"@nestjs/serve-static": "^4.0.0",
"@nestjs/typeorm": "^7.1.5",
"@types/nodemailer": "^6.4.9",
"@types/passport-facebook": "^2.1.11",
"@nestjs/axios": "^3.0.0",
"@nestjs/common": "^9.4.3",
"@nestjs/core": "^9.4.3",
"@nestjs/jwt": "^10.0.3",
"@nestjs/passport": "^9.0.3",
"@nestjs/platform-express": "^9.4.3",
"@nestjs/schedule": "^3.0.2",
"@nestjs/typeorm": "^9.0.1",
"@types/passport-jwt": "^3.0.8",
"archiver": "^5.3.1",
"bcrypt": "^5.0.0",
"class-transformer": "^0.4.0",
"class-validator": "^0.13.1",
"config": "^3.3.3",
"crypto-js": "^4.0.0",
"ifsc": "^2.0.11",
"bcrypt": "^5.1.0",
"class-transformer": "^0.5.1",
"config": "^3.3.9",
"crypto-js": "^4.1.1",
"i": "^0.3.7",
"js-sha512": "^0.8.0",
"jspdf": "^2.3.1",
"jspdf-autotable": "^3.5.14",
"jwt-payload": "^1.0.7",
"node-oracledb": "^1.0.2",
"oracledb": "^5.1.0",
"passport": "^0.4.1",
"passport-facebook": "^3.0.0",
"passport-google-oauth20": "^2.0.0",
"passport-jwt": "^4.0.0",
"jspdf": "^2.5.1",
"jspdf-autotable": "^3.5.31",
"node-forge": "^1.3.1",
"npm": "^9.8.1",
"otp-generator": "^4.0.1",
"passport": "^0.6.0",
"passport-jwt": "^4.0.1",
"payu": "^0.0.1",
"payumoney_nodejs": "^2.0.4",
"pg": "^8.5.1",
"payumoney-node": "^2.0.1",
"pg": "^8.10.0",
"reflect-metadata": "^0.1.13",
"request": "^2.88.2",
"rimraf": "^3.0.2",
"rxjs": "^6.6.6",
"sha512-crypt-ts": "^0.1.27",
"typeorm": "^0.2.31"
"rxjs": "^7.2.0",
"typeorm": "^0.3.16",
"uuid": "^9.0.0"
},
"devDependencies": {
"@nestjs-modules/mailer": "^1.8.1",
"@nestjs/cli": "^7.5.6",
"@nestjs/schematics": "^7.2.7",
"@nestjs/testing": "^7.6.13",
"@types/cron": "^1.7.3",
"@types/crypto-js": "^4.0.1",
"@types/express": "^4.17.11",
"@types/jest": "^26.0.20",
"@types/node": "^14.14.31",
"@types/supertest": "^2.0.10",
"@typescript-eslint/eslint-plugin": "^4.15.2",
"@typescript-eslint/parser": "^4.15.2",
"eslint": "^7.20.0",
"eslint-config-prettier": "^8.1.0",
"eslint-plugin-prettier": "^3.3.1",
"jest": "^26.6.3",
"nodemailer": "^6.9.3",
"otp-generator": "^2.0.0",
"prettier": "^2.2.1",
"@nestjs/cli": "^9.5.0",
"@nestjs/schematics": "^9.2.0",
"@nestjs/testing": "^9.4.3",
"@types/crypto-js": "^4.1.1",
"@types/express": "^4.17.13",
"@types/jest": "28.1.8",
"@types/node": "^16.0.0",
"@types/supertest": "^2.0.11",
"@typescript-eslint/eslint-plugin": "^5.0.0",
"@typescript-eslint/parser": "^5.0.0",
"eslint": "^8.0.1",
"eslint-config-prettier": "^8.3.0",
"eslint-plugin-prettier": "^4.0.0",
"jest": "28.1.3",
"prettier": "^2.3.2",
"source-map-support": "^0.5.20",
"supertest": "^6.1.3",
"ts-jest": "^26.5.2",
"ts-loader": "^8.0.17",
"ts-node": "^9.1.1",
"tsconfig-paths": "^3.9.0",
"typescript": "^4.1.5"
"ts-jest": "28.0.8",
"ts-loader": "^9.2.3",
"ts-node": "^10.0.0",
"tsconfig-paths": "4.1.0",
"typescript": "^4.7.4"
},
"jest": {
"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 { PaymentStatusModule } from './tables/payment-status/payment-status.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({
@ -30,7 +34,7 @@ import { PaymentMasterModule } from './tables/payment-master/payment-master.modu
FileUploadModule,
AuthModule,
TenderDetailsModule,
FormOfContractModule,
FormOfContractModule,
PaymentModeModule,
TenderTypeModule,
ProductCategoryModule,
@ -45,8 +49,13 @@ import { PaymentMasterModule } from './tables/payment-master/payment-master.modu
PaymentGatewayModule,
PayuTransactionListModule,
PaymentStatusModule,
PaymentMasterModule
PaymentMasterModule,
CommonModule,
ReportAuthenticationModule,
],
})
export class AppModule { }
export class AppModule {
constructor(private dataSource: DataSource) {}
}

@ -18,7 +18,7 @@ import { UserBankDto } from './dto/user-bank.dto';
export class AuthController {
constructor(
private authService: AuthService
) { }
) {}
@Post('/user-info')
async userInfo(@Body() authCredentialDto: AuthCreadentialsDto) {
@ -33,20 +33,11 @@ export class AuthController {
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()
async getall() {
return this.authService
}
@Post('/signup')
async signUp(@Body() pcdUserDto: PcduserDto): Promise<any> {
// request.connection.remoteAddress
@ -64,9 +55,11 @@ export class AuthController {
@Post('/otp/:flag')
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
): Promise<void> {
console.log("helo==========================");
return await this.authService.sendOtp(body, flag);
}
@ -85,53 +78,4 @@ export class AuthController {
): Promise<any> {
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 { AuthController, AuthUserController } from './auth.controller';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import * as config from 'config';
@ -13,6 +13,8 @@ import { PcduserRepository } from './pcduser.repository';
import { PcdotpRepository } from './pcdotp.repository';
import { EmailService } from 'src/email/email.service';
import { EmailModule } from 'src/email/email.module';
import { Pcduser } from './pcduser.entity';
import { Pcdotp } from './pcdotp.entity';
const jwtConfig = config.get('jwt');
@ -27,16 +29,18 @@ const jwtConfig = config.get('jwt');
}
}),
TypeOrmModule.forFeature([
PcduserRepository,
PcdotpRepository,
Pcduser,
Pcdotp,
]),EmailModule,
],
controllers: [AuthController, AuthUserController],
controllers: [AuthController],
providers: [
AuthService,
CryptoService,
JwtStrategy,
PcdotpRepository,
PcduserRepository

@ -4,9 +4,9 @@ import * as config from 'config';
import { v4 as uuidv4 } from 'uuid';
const https = require('https');
const fs = require('fs');
import { CryptoService } from './crypto.service';
import { CryptoService } from './crypto.service';
import { AuthCreadentialsDto } from './dto/auth-credentials.dto';
import { TokenDto } from './dto/token.dto';
import { TokenDto } from './dto/token.dto';
import { JwtPayload } from './jwt-payload.interface';
import { PcduserDto } from 'src/auth/dto/pcd-user.dto';
import { Connection, createConnection, FindManyOptions, getConnection, getCustomRepository, In, IsNull, Like, Not, QueryRunner } from 'typeorm';
@ -39,10 +39,10 @@ export class AuthService {
constructor(
@InjectRepository(PcduserRepository)
private pcduserRepository: PcduserRepository,
private readonly pcduserRepository: PcduserRepository,
private jwtService: JwtService,
private crypto: CryptoService,
private pcdotpRepository: PcdotpRepository,
private readonly pcdotpRepository: PcdotpRepository,
private mailService: EmailService
) {
@ -55,7 +55,7 @@ export class AuthService {
async userInfo(authCredentialsDto: AuthCreadentialsDto) {
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) {
throw new BadRequestException('User Details not found')
}
@ -78,7 +78,7 @@ export class AuthService {
async validateUserPassword(authCredentialsDto: AuthCreadentialsDto): Promise<Pcduser> {
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);
if (!user) {
throw new UnauthorizedException('User not Registered')
@ -396,16 +396,107 @@ export class AuthService {
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);
}
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 (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 } });
@ -427,6 +518,9 @@ export class AuthService {
if (body.email && flag == 'UD') {
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');
}
}
@ -526,8 +620,8 @@ export class AuthService {
const newOtp = await otpGenerator.generate(6, { upperCase: false, specialChars: false, alphabets: false });
console.log("===newOtp====", newOtp);
let usedFor: string = '';
let usedFor: string = '';
switch (flag) {
case "R":

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

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

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

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

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

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

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

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

@ -1,62 +1,62 @@
export class TenderDetailDto{
createdBy: string;
createdDate: string;
modifiedBy: string;
modifiedDate: string;
versionNo: number;
sessionNo: number;
id: number;
orgChain: string;
tenderRefNo: string;
tenderId: string;
allowTechEval: string;
paymentMode: number;
allowWithdraw: string;
noOfCovers: number;
itemwiseTechEval: string;
allowTwoStageBid: string;
tenderFee: number;
feePayableTo: string;
feePayableAt: string;
tenderFeeExemption: number;
emdAmt: number;
emdPayableTo: string;
allowEmdBgOrSt: string;
emdPercentage: number;
emdPayableAt: string;
title: string;
workDesc: string;
ndaPreQualification: string;
remarks: string;
tenderValue: number;
contractType: string;
location: string;
preBidMeetAdd: string;
allowNdaTender: string;
productCategory: number;
bidValidity: number;
pincode: number;
preBidDate: Date;
export class TenderDetailDto {
createdBy: string;
createdDate: string;
modifiedBy: string;
modifiedDate: string;
versionNo: number;
sessionNo: number;
id: number;
orgChain: string;
tenderRefNo: string;
tenderId: string;
allowTechEval: string;
paymentMode: number;
allowWithdraw: string;
noOfCovers: number;
itemwiseTechEval: string;
allowTwoStageBid: string;
tenderFee: number;
feePayableTo: string;
feePayableAt: string;
tenderFeeExemption: number;
emdAmt: number;
emdPayableTo: string;
allowEmdBgOrSt: string;
emdPercentage: number;
emdPayableAt: string;
title: string;
workDesc: string;
ndaPreQualification: string;
remarks: string;
tenderValue: number;
contractType: string;
location: string;
preBidMeetAdd: string;
allowNdaTender: string;
productCategory: number;
bidValidity: number;
pincode: number;
preBidDate: Date;
allowPreferencialBidder: string;
subCategory: string;
periodOfWork: number;
preBidMeetPlace: string;
bidOpeningPlace: string;
publishDate: Date;
saleStartDate: Date;
clarificationStartDate: Date;
bidSubStartDate: Date;
bidOpenDate: Date;
saleEndDate: Date;
clarificationEndDate: Date;
bidSubEndDate: Date;
tenderInvName: string;
tenderInvAddess: string;
tenderType: number;
tenderCategory: number;
formOfContract: number;
emdFeeType: string;
activeYn: string;
sendReport : string;
bidOpenAddress : string
subCategory: string;
periodOfWork: number;
preBidMeetPlace: string;
bidOpeningPlace: string;
publishDate: Date;
saleStartDate: Date;
clarificationStartDate: Date;
bidSubStartDate: Date;
bidOpenDate: Date;
saleEndDate: Date;
clarificationEndDate: Date;
bidSubEndDate: Date;
tenderInvName: string;
tenderInvAddess: string;
tenderType: number;
tenderCategory: number;
formOfContract: number;
emdFeeType: string;
activeYn: string;
sendReport: string;
bidOpenAddress: string
}

@ -41,7 +41,7 @@ export function createFolders(filePath: string) {
export class FileUploadController {
constructor(
@InjectRepository(tenderDocRepository)
private tenderDocRepository:tenderDocRepository,
private readonly tenderDocRepository:tenderDocRepository,
private iservice: FileUploadService,
) {
@ -140,7 +140,7 @@ export class FileUploadController {
await fs.promises.unlink(filePath);
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) {
console.log('helloooooo');
await this.tenderDocRepository.remove(deletedEntry);
@ -166,7 +166,7 @@ async deleteUserDoc(
await fs.promises.unlink(filePath);
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) {
console.log('helloooooo');
await this.tenderDocRepository.remove(deletedEntry);
@ -190,7 +190,7 @@ async deleteBankDoc(
await fs.promises.unlink(filePath);
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) {
console.log('helloooooo');
await this.tenderDocRepository.remove(deletedEntry);
@ -215,7 +215,7 @@ async deleteNotice(
await fs.promises.unlink(filePath);
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) {
console.log('helloooooo');
await this.tenderDocRepository.remove(deletedEntry);
@ -355,9 +355,9 @@ async deleteNotice(
readStream.pipe(res);
// Remove the temporary zip file once it's streamed
readStream.on('end', () => {
readStream.on('end', () => {
fs.unlinkSync(zipPath);
});
});
// Handle any errors that occur during the archiving process
archive.on('error', function (err) {

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

@ -2,10 +2,6 @@ import { BadRequestException, ConflictException, HttpException, InternalServerEr
import { PcduserDto } from 'src/auth/dto/pcd-user.dto';
import { FindManyOptions, Not, Repository } from 'typeorm';
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 {
@ -124,11 +120,7 @@ export class PcdFormGridService<T> implements PcdFormGridInterface {
return true;
}
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) {
if (!body[colMan] || body[colMan].toString().trim() == "") {

@ -1,5 +1,5 @@
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 { TransactionDetailDto } from "src/framework/custom/transaction-detail.dto";
import { PcduserDto } from "src/auth/dto/pcd-user.dto";
@ -16,9 +16,9 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
DETAIL_DATA_FORMAT: TransactionDetailDto[] = [];
constructor(
private connection: Connection,
private connection: DataSource,
private repo: Repository<any>
) { }
) { }
async preFindList(filter: FindManyOptions, user: PcduserDto): Promise<boolean> {
return true
@ -45,7 +45,7 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
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 (this.TXN_TYPE) filter.where[this.DETAIL_DATA_FORMAT[0].transactionTypeColumnName] = this.TXN_TYPE;
let orgFilter = Object.create(filter);
@ -55,12 +55,14 @@ export class PcdTransactionService<T> implements PcdtTransactionInterface {
if (!await this.preFindOne(filter))
throw new BadRequestException(`Unepected Error Occured in findOne`);
//branch right check();
let result: T = await this.repo.findOne(filter);
if (!result)
return result;
result = await this.getDetailData(result, orgFilter, this.DETAIL_DATA_FORMAT);
result = await this.getDetailData(result, orgFilter, this.DETAIL_DATA_FORMAT);
return await this.postFindOne(filter, result);
}

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

@ -85,7 +85,7 @@ export class PaymentGatewayController {
console.log(paymentSuccessBody);
const userId = paymentSuccessBody.lastname.split('ESC')[1];
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);
this.paymentGatewayService.paymentSuccess(paymentSuccessBody, (error, result) => {
@ -126,7 +126,7 @@ export class PaymentGatewayController {
const paymentFailureBody = req.body;
const userId = paymentFailureBody.lastname.split('ESC')[1];
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);
this.paymentGatewayService.paymentFailure(paymentFailureBody, (error, result) => {
console.log(paymentFailureBody);

@ -1,4 +1,4 @@
import { HttpModule, Module } from '@nestjs/common';
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from 'src/auth/auth.module';
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 { EmailModule } from 'src/email/email.module';
import { PaymentStatusRepository } from 'src/tables/payment-status/payment-status.repository';
import { HttpModule } from '@nestjs/axios';
import { PaymentGatewayController } from './payment-gateway.controller';
import { PaymentGatewayService } from './payment-gateway.service';
@ -17,9 +16,9 @@ import { PaymentMasterRepository } from 'src/tables/payment-master/payment-maste
imports: [
TypeOrmModule.forFeature([
PaymentStatusRepository,
PaymentMasterRepository,
PaymentStatusRepository,
PaymentMasterRepository,
]), AuthModule,
HttpModule.register({

@ -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 { AuthService } from 'src/auth/auth.service';
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 { convertDate } from 'src/pipe/pcd-date.pipe';
var crypto = require('crypto')
import fetch from "node-fetch";
import { PayuTransactionListDto } from 'src/dto/payu-transaction-list.dto';
import { PayuTransactionListRepository } from 'src/tables/payu-transaction-list/payu-transaction-list.repository';
import { PcduserDto } from 'src/auth/dto/pcd-user.dto';
import { PaymentMasterDto } from 'src/dto/payment-master.dto';
import { Console } from 'console';
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 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 { AuthModule } from 'src/auth/auth.module';
import { CoversLovRepository } from './covers-lov.repository';
import { CoversLov } from './covers-lov.entity';
@Module({
imports: [
TypeOrmModule.forFeature([CoversLovRepository]),
TypeOrmModule.forFeature([CoversLov]),
],
controllers: [CoversLovController],
providers: [CoversLovService]
providers: [CoversLovService,CoversLovRepository]
})
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 { Injectable } from "@nestjs/common";
@EntityRepository(CoversLov)
@Injectable()
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 { AuthModule } from 'src/auth/auth.module';
import { CoverMasterRepository } from './covers-master.repository';
import { CoverDoc } from './covers-master.entity';
@Module({
imports: [
TypeOrmModule.forFeature([CoverMasterRepository]),
TypeOrmModule.forFeature([CoverDoc]),
AuthModule
],
providers: [CoversMasterService],
providers: [CoversMasterService,CoverMasterRepository],
controllers: [CoversMasterController]
})
export class CoversMasterModule {}

@ -1,7 +1,11 @@
import { EntityRepository, Repository } from "typeorm";
import { CoverDoc } from "./covers-master.entity";
import { DataSource, Repository } from "typeorm";
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 { DocumentTypeRepository } from './document-type.repository';
import { AuthModule } from 'src/auth/auth.module';
import { DocumentType } from './document-type.entity';
@Module({
imports: [
TypeOrmModule.forFeature([DocumentTypeRepository]),
TypeOrmModule.forFeature([DocumentType]),
AuthModule
],
controllers: [DocumentTypeController],
providers: [DocumentTypeService]
providers: [DocumentTypeService,DocumentTypeRepository]
})
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 { Injectable } from "@nestjs/common";
@EntityRepository(DocumentType)
@Injectable()
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 { EmdFeeTypeRepository } from './emd-fee-type.repository';
import { AuthModule } from 'src/auth/auth.module';
import { EmdFeeType } from './emd-fee-type.entity';
@Module({
imports: [
TypeOrmModule.forFeature([EmdFeeTypeRepository]),
TypeOrmModule.forFeature([EmdFeeType]),
AuthModule
],
controllers: [EmdFeeTypeController],
providers: [EmdFeeTypeService]
providers: [EmdFeeTypeService,EmdFeeTypeRepository]
})
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 { Injectable } from "@nestjs/common";
@EntityRepository(EmdFeeType)
@Injectable()
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 { FileFormatRepository } from './file-format-lov.repository';
import { AuthModule } from 'src/auth/auth.module';
import { FileFormat } from './file-format-lov.entity';
@Module({
imports: [
TypeOrmModule.forFeature([FileFormatRepository]),
TypeOrmModule.forFeature([FileFormat]),
],
providers: [FileFormatLovService],
providers: [FileFormatLovService,FileFormatRepository],
controllers: [FileFormatLovController]
})
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 { Inject, Injectable } from "@nestjs/common";
@EntityRepository(FileFormat)
@Injectable()
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 { FormOfContractRepository } from './form-of-contract.repository';
import { AuthModule } from 'src/auth/auth.module';
import { FormOfContract } from './form-of-contract.entity';
@Module({
imports: [
TypeOrmModule.forFeature([FormOfContractRepository]),
TypeOrmModule.forFeature([FormOfContract]),
AuthModule
],
controllers: [FormOfContractController],
providers: [FormOfContractService]
providers: [FormOfContractService,FormOfContractRepository]
})
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 { Injectable } from "@nestjs/common";
@EntityRepository(FormOfContract)
@Injectable()
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>{
}

@ -3,7 +3,7 @@ import { PaymentMasterDto } from 'src/dto/payment-master.dto';
import { PcdFormGridController } from 'src/framework/beans/pcd-form-grid.controller';
import { PaymentMasterService } from './payment-master.service';
import { AuthGuard } from '@nestjs/passport';
//@UseGuards(AuthGuard())
// @UseGuards(AuthGuard())
@Controller('payment-master')
export class PaymentMasterController extends PcdFormGridController<PaymentMasterDto> {
@ -21,7 +21,6 @@ export class PaymentMasterController extends PcdFormGridController<PaymentMaster
return this.paymentMasterService.bidReport(tenderId)
}
@Get('bid-payment-check/:userId/:tenderId')
async bidPaymentCheck(
@Param('userId') userId: string,
@ -63,5 +62,11 @@ export class PaymentMasterController extends PcdFormGridController<PaymentMaster
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
@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 })
@JoinColumn([{ name: "user_id", referencedColumnName: "userId" }])

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

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm";
import { DataSource, Repository } from "typeorm";
import { PaymentMaster } from "./payment-master.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(PaymentMaster)
@Injectable()
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){
let user = await this.paymentMasterRepository.findOne({ tenderId:tenderId , userId:userId });
let user = await this.paymentMasterRepository.findOne({where:{ tenderId:tenderId , userId:userId }});
if(!user){
throw new BadRequestException('User Details not found')
}
@ -91,18 +91,37 @@ async paymentInfo(paymentMasterDto) {
async AdminUpdatePaymentStatus(userId , tenderId , body){
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);
user.status = body.status;
user.message = body.message;
user.notificationViewed= body.notificationViewed;
let result = await this.paymentMasterRepository.save(user);
return {data: "Payment Status Updated Successfully" }
return {data: "Payment Status Updated Successfully" }
}catch(err){
console.log(err);
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 { PaymentModeRepository } from './payment-mode.repository';
import { AuthModule } from 'src/auth/auth.module';
import { PaymentMode } from './payment-mode.entity';
@Module({
imports: [
TypeOrmModule.forFeature([PaymentModeRepository]),
TypeOrmModule.forFeature([PaymentMode]),
AuthModule
],
controllers: [PaymentModeController],
providers: [PaymentModeService]
providers: [PaymentModeService,PaymentModeRepository]
})
export class PaymentModeModule {}

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm";
import { DataSource, Repository } from "typeorm";
import { PaymentMode } from "./payment-mode.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(PaymentMode)
@Injectable()
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 { PaymentStatusRepository } from './payment-status.repository';
import { PaymentStatusService } from './payment-status.service';
import { PaymentStatus } from './payment-status.entity';
@Module({
imports: [
TypeOrmModule.forFeature([
PaymentStatusRepository
PaymentStatus
]),
AuthModule
],
controllers: [PaymentStatusController],
providers: [PaymentStatusService]
providers: [PaymentStatusService,PaymentStatusRepository]
})
export class PaymentStatusModule { }

@ -1,7 +1,12 @@
import { EntityRepository, Repository } from "typeorm";
import { DataSource, Repository } from "typeorm";
import { PaymentStatus } from "./payment-status.entity";
import { Injectable } from "@nestjs/common";
@EntityRepository(PaymentStatus)
@Injectable()
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 { PayuTransactionListController } from './payu-transaction-list.controller';
import { PayuTransactionListRepository } from './payu-transaction-list.repository';
import { PcduserRepository } from 'src/auth/pcduser.repository';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AuthModule } from 'src/auth/auth.module';
import { HttpModule} from '@nestjs/axios';
import { PayuTransactionListEntity } from './payu-transaction-list.entity';
@Module({
imports: [
TypeOrmModule.forFeature([
PayuTransactionListRepository,
PayuTransactionListEntity
]),
AuthModule,
HttpModule
],
providers: [PayuTransactionListService],
providers: [PayuTransactionListService,PayuTransactionListRepository],
controllers: [PayuTransactionListController],
exports: [PayuTransactionListService]
})

@ -1,8 +1,13 @@
import { Logger } from "@nestjs/common";
import { EntityRepository, Repository } from "typeorm";
import { Injectable, Logger } from "@nestjs/common";
import { DataSource, EntityRepository, Repository } from "typeorm";
import { PayuTransactionListEntity } from "./payu-transaction-list.entity";
@EntityRepository(PayuTransactionListEntity)
@Injectable()
export class PayuTransactionListRepository extends Repository<PayuTransactionListEntity>{
constructor(
private datasource:DataSource
){
super(PayuTransactionListEntity,datasource.createEntityManager());
}
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 { InjectRepository } from '@nestjs/typeorm';
import * as config from 'config';
@ -10,6 +10,7 @@ import { convertDateString } from 'src/pipe/pcd-date.pipe';
import { FindManyOptions, In } from 'typeorm';
import { PayuTransactionListRepository } from './payu-transaction-list.repository';
import { sha512 } from 'js-sha512';
import { HttpService } from '@nestjs/axios';
@Injectable()

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

@ -1,7 +1,11 @@
import { EntityRepository, Repository } from "typeorm";
import { DataSource, EntityRepository, Repository } from "typeorm";
import { ProductCategory } from "./product-category.entity";
@EntityRepository(ProductCategory)
import { Inject, Injectable } from "@nestjs/common";
@Injectable()
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 { TenderCategoryRepository } from './tender-category.repository';
import { AuthModule } from 'src/auth/auth.module';
import { TenderCategory } from './tender-category.entity';
@Module({
imports: [
TypeOrmModule.forFeature([TenderCategoryRepository]),
TypeOrmModule.forFeature([TenderCategory]),
AuthModule
],
controllers: [TenderCategoryController],
providers: [TenderCategoryService]
providers: [TenderCategoryService,TenderCategoryRepository]
})
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 { Injectable } from "@nestjs/common";
@EntityRepository(TenderCategory)
@Injectable()
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";
@EntityRepository(TenderDoc)
import { Injectable } from "@nestjs/common";
@Injectable()
export class tenderDocRepository extends Repository<TenderDoc>{
constructor(private dataSource: DataSource) {
super(TenderDoc, dataSource.createEntityManager());
}
}

@ -3,13 +3,14 @@ import { TenderDetailsController } from './tender-details.controller';
import { TenderDetailsService } from './tender-details.service';
import { TenderMasterRepository } from './tender-master.repository';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TenderMaster } from './tender-master.entity';
@Module({
imports: [
TypeOrmModule.forFeature([
TenderMasterRepository
TenderMasterRepository
])
],
controllers: [TenderDetailsController],

@ -14,7 +14,7 @@ export class TenderDetailsService extends PcdFormGridService<TenderDetailDto>{
constructor(
@InjectRepository(TenderMasterRepository)
private tenderMasterRepository: TenderMasterRepository,
private tenderMasterRepository: TenderMasterRepository,
) {
super(tenderMasterRepository);
}

@ -1,5 +1,4 @@
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 { FormOfContract } from "src/tables/form-of-contract/form-of-contract.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)
coverDoc: CoverDoc[]
@OneToMany(() => paymentInstrument, (paymentInstrument) => paymentInstrument.tenderIdD)
paymentInstrument: paymentInstrument[]
// @OneToMany(() => paymentInstrument, (paymentInstrument) => paymentInstrument.tenderIdD)
// paymentInstrument: paymentInstrument[]
@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 { Injectable } from "@nestjs/common";
@EntityRepository(TenderMaster)
export class TenderMasterRepository extends Repository<TenderMaster>{}
@Injectable()
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 { TenderTypeRepository } from './tender-type.repository';
import { AuthModule } from 'src/auth/auth.module';
import { TenderType } from './tender-type.entity';
@Module({
imports: [
TypeOrmModule.forFeature([TenderTypeRepository]),
TypeOrmModule.forFeature([TenderType]),
AuthModule
],
controllers: [TenderTypeController],
providers: [TenderTypeService]
providers: [TenderTypeService,TenderTypeRepository]
})
export class TenderTypeModule {}

@ -1,6 +1,11 @@
import { EntityRepository, Repository } from "typeorm";
import { DataSource, EntityRepository, Repository } from "typeorm";
import { TenderType } from "./tender-type.entity";
@EntityRepository(TenderType)
import { Injectable } from "@nestjs/common";
@Injectable()
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 { PcdTransactionController } from 'src/framework/beans/pcd-transaction.controller';
import { TenderService } from './tender.service';
@ -14,7 +14,7 @@ export class TenderController extends PcdTransactionController<TenderDetailDto>
) {
super(tenderService);
}
@UseGuards(AuthGuard())
@Get('admin')
async getTender(
@Query() filter: FindManyOptions,
@ -22,11 +22,21 @@ export class TenderController extends PcdTransactionController<TenderDetailDto>
return this.tenderService.GetAdminTenderD(filter)
}
@UseGuards(AuthGuard())
@Get('admin/dashboard')
async getDashboard() {
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 { TenderMasterRepository } from 'src/tables/tender-master/tender-master.repository';
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({
imports: [
TypeOrmModule.forFeature([TenderMasterRepository]),
TypeOrmModule.forFeature([TenderMaster,
TenderDoc,
CoverDoc]),
AuthModule
],
controllers: [TenderController],
providers: [TenderService]
providers: [TenderService,
TenderMasterRepository,
tenderDocRepository,
CoverMasterRepository
]
})
export class TenderModule {}

@ -1,4 +1,4 @@
import { Injectable } from '@nestjs/common';
import { Injectable, NotFoundException } 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';
@ -7,7 +7,7 @@ import { TransactionDetailDto } from 'src/framework/custom/transaction-detail.dt
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, FindManyOptions, LessThanOrEqual, MoreThanOrEqual } from 'typeorm';
import { DataSource, FindManyOptions, LessThanOrEqual, MoreThanOrEqual } from 'typeorm';
@Injectable()
export class TenderService extends PcdTransactionService<TenderDetailDto>{
@ -15,7 +15,7 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
DETAIL_DATA_FORMAT: TransactionDetailDto[] = [
{
detailName: "tenderDoc", repo: this.conn.getCustomRepository(tenderDocRepository),
detailName: "tenderDoc", repo: this.tenderDocRepository,
filter: [{ columnName: "tenderId", headerColumn: "id" }],
foreignKeyColumnName: "tenderId",
childDetail: [],
@ -23,7 +23,7 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
orderByColumn: { columnName: "id", sort: "DESC" }
},
{
detailName: "covers", repo: this.conn.getCustomRepository(CoverMasterRepository),
detailName: "covers", repo: this.coverMasterRepository,
filter: [{ columnName: "tenderId", headerColumn: "id" }],
foreignKeyColumnName: "tenderId",
childDetail: [],
@ -32,15 +32,19 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
}
];
constructor(
private conn: Connection,
private conn: DataSource,
@InjectRepository(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)
}
async preFindList(filter: FindManyOptions, user: PcduserDto): Promise<boolean> {
async preFindList(filter: FindManyOptions, user: PcduserDto): Promise<any> {
if (!filter.where) filter.where = {};
if (!user || user.secuLevel == 'U') {
filter.where["publishDate"] = LessThanOrEqual(new Date());
@ -51,13 +55,28 @@ export class TenderService extends PcdTransactionService<TenderDetailDto>{
}
async GetAdminTenderD(
filter:FindManyOptions
filter: FindManyOptions
) {
return this.tenderMasterRepository.find(filter)
}
async GetAdminDashboard(){
async GetAdminDashboard() {
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)
}
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",
"baseUrl": "./",
"incremental": true,
"resolveJsonModule": true
"resolveJsonModule": true,
}
}

Loading…
Cancel
Save