1148 lines
36 KiB
TypeScript
1148 lines
36 KiB
TypeScript
import express from 'express';
|
|
import { Request, Response, NextFunction } from 'express';
|
|
import { getRepository, getConnection } from 'typeorm';
|
|
import { validationMiddleware, redisMiddleware } from '../middlewares';
|
|
import { Global } from "../global";
|
|
import * as path from 'path';
|
|
import {
|
|
InternalServerErrorException,
|
|
NoDataFoundException,
|
|
} from '../exceptions';
|
|
import { BlockchainKernel } from '../entities';
|
|
import {
|
|
BlockchainKernelCreateDto,
|
|
BlockchainKernelSingleViewDto,
|
|
BlockchainKernelUpdateDto,
|
|
BlockchainKernelPaginationDto,
|
|
TransactionFeeDto,
|
|
} from '../dtos';
|
|
import { Paginate } from '../utils';
|
|
const http = require('http');
|
|
const request_promise = require('request-promise');
|
|
|
|
var moment = require('moment');
|
|
|
|
export class BlockchainKernelController {
|
|
public path = '/blockchain_kernel';
|
|
public router = express.Router();
|
|
|
|
constructor() {
|
|
this.IntializeRoutes();
|
|
}
|
|
|
|
IsJsonString(str) {
|
|
try {
|
|
var dataJson = JSON.parse(str);
|
|
} catch (e) {
|
|
return [];
|
|
}
|
|
return dataJson;
|
|
}
|
|
|
|
public IntializeRoutes() {
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/blockchain_kernel:
|
|
* post:
|
|
* tags:
|
|
* - name: BLOCKCHAIN_KERNEL | BLOCKCHAIN_KERNEL CONTROLLER
|
|
* summary: create a blockchain_kernel
|
|
* description: create a blockchain_kernel
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: BlockchainKernel
|
|
* description: create a blockchain_kernel
|
|
* in: body
|
|
* required: true
|
|
* schema:
|
|
* $ref: '#/definitions/BlockchainKernelDto'
|
|
* responses:
|
|
* 200:
|
|
* description: blockchain_kernel created successfully
|
|
* definitions:
|
|
* BlockchainKernelDto:
|
|
* description: Dto
|
|
* properties:
|
|
* Id:
|
|
* type: integer
|
|
* Features:
|
|
* type: string
|
|
* Fee:
|
|
* type: integer
|
|
* LockHeight:
|
|
* type: integer
|
|
* Excess:
|
|
* type: string
|
|
* ExcessSig:
|
|
* type: string
|
|
* Block:
|
|
* type: string
|
|
*/
|
|
|
|
this.router.post(
|
|
`${this.path}`,
|
|
validationMiddleware(BlockchainKernelCreateDto),
|
|
redisMiddleware(process.env.REDIS_EXPIRY),
|
|
this.BlockchainKernelCreate,
|
|
);
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/blockchain_kernel/transactionfee:
|
|
* get:
|
|
* tags:
|
|
* - name: BLOCKCHAIN_KERNEL | BLOCKCHAIN_KERNEL CONTROLLER
|
|
* summary: create a blockchain_kernel
|
|
* description: create a blockchain_kernel
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: FromDate
|
|
* description: Enter the From date
|
|
* in: query
|
|
* type: string
|
|
* - name: ToDate
|
|
* description: Enter the To date
|
|
* in: query
|
|
* type: string
|
|
* - name: Interval
|
|
* description: Try to give Intevals such as 1 week/ 15 days/ 30 days/ 60 days/ 3 months
|
|
* in: query
|
|
* type: string
|
|
* responses:
|
|
* 200:
|
|
* description: Transaction fee chart fetched successfully
|
|
*/
|
|
this.router.get(
|
|
`${this.path}/transactionfee`,
|
|
validationMiddleware(TransactionFeeDto, true),
|
|
redisMiddleware(process.env.REDIS_EXPIRY),
|
|
this.TransactionFee,
|
|
);
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/translator:
|
|
* get:
|
|
* tags:
|
|
* - name: Translator | Translator CONTROLLER
|
|
* summary: create a translator
|
|
* description: create a translator
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: lang
|
|
* responses:
|
|
* 200:
|
|
* description: Transaction fee chart fetched successfully
|
|
*/
|
|
this.router.get(
|
|
`${this.path}/translator`,
|
|
this.Translator,
|
|
);
|
|
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/network:
|
|
* get:
|
|
* tags:
|
|
* - name: Network | Network CONTROLLER
|
|
* summary: change a network
|
|
* description: change a network
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: network
|
|
* responses:
|
|
* 200:
|
|
* description: Network Changed successfully
|
|
*/
|
|
this.router.get(
|
|
`${this.path}/network`,
|
|
this.changeNetwok,
|
|
);
|
|
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/getpeers:
|
|
* get:
|
|
* tags:
|
|
* - name: Translator | Translator CONTROLLER
|
|
* summary: create a translator
|
|
* description: create a translator
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: lang
|
|
* responses:
|
|
* 200:
|
|
* description: Transaction fee chart fetched successfully
|
|
*/
|
|
this.router.get(
|
|
`${this.path}/getpeers`,
|
|
redisMiddleware(60),
|
|
this.getPeers,
|
|
);
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/blockchain_kernel/transactionheatmap:
|
|
* get:
|
|
* tags:
|
|
* - name: BLOCKCHAIN_KERNEL | BLOCKCHAIN_KERNEL CONTROLLER
|
|
* summary: Transaction Heatmap
|
|
* description: Transaction Heatmap (Input/output/kernal)
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* responses:
|
|
* 200:
|
|
* description: Transaction heatmap chart fetched successfully
|
|
*/
|
|
this.router.get(
|
|
`${this.path}/transactionheatmap`,
|
|
validationMiddleware(TransactionFeeDto, true),
|
|
redisMiddleware(process.env.REDIS_EXPIRY),
|
|
this.HeatmapChart,
|
|
);
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/blockchain_kernel/transactionlinechart:
|
|
* get:
|
|
* tags:
|
|
* - name: BLOCKCHAIN_KERNEL | BLOCKCHAIN_KERNEL CONTROLLER
|
|
* summary: Transaction line chart
|
|
* description: Transaction line chart
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: FromDate
|
|
* description: Enter the From date
|
|
* in: query
|
|
* type: string
|
|
* - name: ToDate
|
|
* description: Enter the To date
|
|
* in: query
|
|
* type: string
|
|
* - name: Interval
|
|
* description: Try to give Intevals such as 1 week/ 15 days/ 30 days/ 60 days/ 3 months
|
|
* in: query
|
|
* type: string
|
|
* responses:
|
|
* 200:
|
|
* description: Transaction line chart fetched successfully
|
|
*/
|
|
this.router.get(
|
|
`${this.path}/transactionlinechart`,
|
|
validationMiddleware(TransactionFeeDto, true),
|
|
redisMiddleware(process.env.REDIS_EXPIRY),
|
|
this.TransactionChart,
|
|
);
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/blockchain_kernel/list:
|
|
* get:
|
|
* tags:
|
|
* - name: BLOCKCHAIN_KERNEL | BLOCKCHAIN_KERNEL CONTROLLER
|
|
* description: pagination blockchain_kernel
|
|
* summary: pagination blockchain_kernel
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: current_page
|
|
* description: current page specification
|
|
* in: query
|
|
* type: integer
|
|
* required: true
|
|
* - name: page_size
|
|
* description: page size specification
|
|
* in: query
|
|
* type: integer
|
|
* required: true
|
|
* - name: max_pages
|
|
* description: max pages specification
|
|
* in: query
|
|
* type: integer
|
|
* required: true
|
|
* responses:
|
|
* 200:
|
|
* description: blockchain_kernel list fetched successfully
|
|
*/
|
|
this.router.get(
|
|
`${this.path}/list`,
|
|
validationMiddleware(BlockchainKernelPaginationDto),
|
|
redisMiddleware(process.env.REDIS_EXPIRY),
|
|
this.BlockchainKernelPagination,
|
|
);
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/blockchain_kernel/id:
|
|
* get:
|
|
* tags:
|
|
* - name: BLOCKCHAIN_KERNEL | BLOCKCHAIN_KERNEL CONTROLLER
|
|
* summary: get single blockchain_kernel
|
|
* description: get single blockchain_kernel
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: Id
|
|
* in: path
|
|
* description: blockchain_kernel id
|
|
* required: true
|
|
* type: string
|
|
* responses:
|
|
* 200:
|
|
* description: blockchain_kernel successfully fetched for given id..
|
|
*/
|
|
this.router.get(
|
|
`${this.path}/:id`,
|
|
validationMiddleware(BlockchainKernelSingleViewDto),
|
|
redisMiddleware(process.env.REDIS_EXPIRY),
|
|
this.BlockchainKernelFetch,
|
|
);
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/blockchain_kernel:
|
|
* patch:
|
|
* tags:
|
|
* - name: BLOCKCHAIN_KERNEL | BLOCKCHAIN_KERNEL CONTROLLER
|
|
* summary: update a blockchain_kernel
|
|
* description: update a blockchain_kernel
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: blockchain_kernel
|
|
* description:
|
|
* in: body
|
|
* required: true
|
|
* schema:
|
|
* $ref: '#/definitions/BlockchainKernelDto'
|
|
* responses:
|
|
* 200:
|
|
* description: blockchain_kernel updated successfully
|
|
*/
|
|
this.router.patch(
|
|
`${this.path}`,
|
|
validationMiddleware(BlockchainKernelUpdateDto),
|
|
redisMiddleware(process.env.REDIS_EXPIRY),
|
|
this.BlockchainKernelUpdate,
|
|
);
|
|
|
|
/**
|
|
* @swagger
|
|
* /epic_explorer/v1/blockchain_kernel/id:
|
|
* delete:
|
|
* tags:
|
|
* - name: BLOCKCHAIN_KERNEL | BLOCKCHAIN_KERNEL CONTROLLER
|
|
* summary: delete a blockchain_kernel
|
|
* description: delete a blockchain_kernel
|
|
* consumes:
|
|
* - application/json
|
|
* produces:
|
|
* - application/json
|
|
* parameters:
|
|
* - name: Id
|
|
* in: path
|
|
* description: blockchain_kernel id
|
|
* required: true
|
|
* type: string
|
|
* responses:
|
|
* 200:
|
|
* description: blockchain_kernel successfully deleted for given id..
|
|
*/
|
|
this.router.delete(
|
|
`${this.path}/:id`,
|
|
validationMiddleware(BlockchainKernelSingleViewDto),
|
|
redisMiddleware(process.env.REDIS_EXPIRY),
|
|
this.BlockchainKernelDelete,
|
|
);
|
|
}
|
|
|
|
private BlockchainKernelCreate = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
const BlockchainKernelRequestData: BlockchainKernelCreateDto =
|
|
request.body;
|
|
const BlockchainKernelCreateQuery = await getConnection(Global.network).getRepository(
|
|
BlockchainKernel,
|
|
).save(BlockchainKernelRequestData);
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'blockchain_kernel created successfully',
|
|
response: BlockchainKernelCreateQuery,
|
|
});
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
|
|
private BlockchainKernelFetch = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
const BlockchainKernelFetchQuery = await getConnection(Global.network).getRepository(
|
|
BlockchainKernel,
|
|
).findOne({
|
|
where: { id: request.params.id },
|
|
});
|
|
BlockchainKernelFetchQuery
|
|
? response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'blockchain_kernelsuccessfully fetched for given id.',
|
|
response: { ...BlockchainKernelFetchQuery },
|
|
})
|
|
: next(new NoDataFoundException());
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
|
|
private BlockchainKernelUpdate = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
const BlockchainKernelRequestData: BlockchainKernelUpdateDto =
|
|
request.body;
|
|
const BlockchainKernelUpdateQuery = await getConnection(Global.network).getRepository(
|
|
BlockchainKernel,
|
|
).update(BlockchainKernelRequestData.Id, BlockchainKernelRequestData);
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'blockchain_kernel updated succesfully',
|
|
response: { ...BlockchainKernelUpdateQuery },
|
|
});
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
|
|
private BlockchainKernelDelete = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
const BlockchainKernelDeleteQuery = await getConnection(Global.network).getRepository(
|
|
BlockchainKernel,
|
|
).delete(request.params.Id);
|
|
BlockchainKernelDeleteQuery
|
|
? response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'blockchain_kernel successfully deleted for given id.',
|
|
response: { ...BlockchainKernelDeleteQuery },
|
|
})
|
|
: next(new NoDataFoundException());
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
|
|
private BlockchainKernelPagination = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
const BlockchainKernelRequestData: BlockchainKernelPaginationDto =
|
|
request.query;
|
|
const BlockchainKernelCountQuery = await getConnection(Global.network).getRepository(
|
|
BlockchainKernel,
|
|
).findAndCount({});
|
|
if (BlockchainKernelCountQuery[1]) {
|
|
const PaginationReponseData = Paginate(
|
|
BlockchainKernelCountQuery[1],
|
|
BlockchainKernelRequestData.CurrentPage,
|
|
BlockchainKernelRequestData.PageSize,
|
|
BlockchainKernelRequestData.MaxPages,
|
|
);
|
|
const BlockchainKernelPaginationQuery = await getConnection(Global.network).getRepository(
|
|
BlockchainKernel,
|
|
).find({
|
|
skip: PaginationReponseData.startIndex,
|
|
take: PaginationReponseData.pageSize,
|
|
order: {
|
|
Id: 'DESC',
|
|
},
|
|
});
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'blockchain_kernel list fetched successfully',
|
|
response: {
|
|
...PaginationReponseData,
|
|
...BlockchainKernelPaginationQuery,
|
|
},
|
|
});
|
|
} else {
|
|
next(new NoDataFoundException());
|
|
}
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
|
|
private changeNetwok = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
Global.network = request.query.network;
|
|
console.log(Global.network);
|
|
//const network = request.query.network;
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'Network Changed successfully',
|
|
response: request.query.network,
|
|
});
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
private Translator = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
const lang = request.query.lang;
|
|
|
|
/* response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'Transaction fee chart fetched successfully',
|
|
response: {
|
|
lang: lang
|
|
},
|
|
}); */
|
|
console.log(path.resolve(__dirname + '/../i18n/' + request.query.lang + '.json'));
|
|
console.log("Without :", path.resolve('/../i18n/' + request.query.lang + '.json'));
|
|
response.header("Content-Type", 'application/json');
|
|
response.sendFile(path.resolve(__dirname + '/../i18n/' + request.query.lang + '.json'));
|
|
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
|
|
/*
|
|
private getPeersLocation = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
var self = this;
|
|
try {
|
|
if (Global.network == "Floonet") {
|
|
var peer_url = process.env.FLOONET_PEER_URL;
|
|
} else {
|
|
var peer_url = process.env.TESTNET_PEER_URL;
|
|
}
|
|
let finalresult = await request_promise(peer_url);
|
|
if (finalresult) {
|
|
var jsonresponse = JSON.parse(finalresult);
|
|
}
|
|
|
|
|
|
let getAllIp = [];
|
|
let getExistingIp = [];
|
|
let result = jsonresponse.map(function (value, i) {
|
|
value['id'] = i;
|
|
let getIP = value['addr'].split(':')[0];
|
|
getAllIp.push(getIP);
|
|
return value;
|
|
});
|
|
|
|
const fetchAllIps = await getConnection(Global.network).query(`SELECT ip, longitude, latitude FROM public.peer_ip`);
|
|
|
|
// const fetchAllIps = await getConnection(Global.network).getRepository(
|
|
// PeerIp,
|
|
// ).find({
|
|
// select: ['IpAddress']
|
|
// });
|
|
|
|
let markers = [];
|
|
for (let ip = 0; ip < fetchAllIps.length; ip++) {
|
|
getExistingIp.push(fetchAllIps[ip]['ip'].replace(/['"]+/g, ''));
|
|
const mapMarker = {
|
|
"longitude": fetchAllIps[ip]['longitude'],
|
|
"latitude": fetchAllIps[ip]['latitude']
|
|
};
|
|
|
|
markers.push(mapMarker);
|
|
}
|
|
let users = {};
|
|
users['locations'] = markers;
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'Peers location list fetched successfully',
|
|
response: {
|
|
dataJson: users
|
|
},
|
|
});
|
|
}
|
|
catch (error) {
|
|
console.log('getpeerslocation-error', error);
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
}
|
|
*/
|
|
|
|
/*
|
|
private getPeers = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
var self = this;
|
|
try {
|
|
if (Global.network == "Floonet") {
|
|
var peer_url = process.env.FLOONET_PEER_URL;
|
|
} else {
|
|
var peer_url = process.env.TESTNET_PEER_URL;
|
|
}
|
|
let finalresult = await request_promise(peer_url);
|
|
if (finalresult) {
|
|
var jsonresponse = JSON.parse(finalresult);
|
|
}
|
|
|
|
|
|
let getAllIp = [];
|
|
let getExistingIp = [];
|
|
let result = jsonresponse.map(function (value, i) {
|
|
value['id'] = i;
|
|
let getIP = value['addr'].split(':')[0];
|
|
getAllIp.push(getIP);
|
|
return value;
|
|
});
|
|
|
|
const fetchAllIps = await getConnection(Global.network).query(`SELECT ip, longitude, latitude FROM public.peer_ip`);
|
|
|
|
// const fetchAllIps = await getConnection(Global.network).getRepository(
|
|
// PeerIp,
|
|
// ).find({
|
|
// select: ['IpAddress']
|
|
// });
|
|
|
|
let markers = [];
|
|
for (let ip = 0; ip < fetchAllIps.length; ip++) {
|
|
getExistingIp.push(fetchAllIps[ip]['ip'].replace(/['"]+/g, ''));
|
|
const mapMarker = {
|
|
"longitude": fetchAllIps[ip]['longitude'],
|
|
"latitude": fetchAllIps[ip]['latitude']
|
|
};
|
|
|
|
markers.push(mapMarker);
|
|
}
|
|
let users = {};
|
|
users['locations'] = markers;
|
|
fs.writeFile(path.join(__dirname, "../../", "browser", "assets/geojson.json"), JSON.stringify(users), err => {
|
|
// Checking for errors
|
|
if (err) { throw err; }
|
|
});
|
|
|
|
|
|
const missingIp = getAllIp.filter(item => getExistingIp.indexOf(item) < 0);
|
|
|
|
if (missingIp.length > 0) {
|
|
fs.readFile(path.join(__dirname, "../../", "browser", "assets/geojson.json"), (err, data) => {
|
|
if (err) { throw err; }
|
|
const users = JSON.parse(data);
|
|
|
|
for (let i = 0; i < missingIp.length; i++) {
|
|
const markers = [];
|
|
const ips = missingIp[i];
|
|
httpRequest(`https://api.ipgeolocationapi.com/geolocate/${ips}`, async (error, response, resp) => {
|
|
if (error) { throw error; }
|
|
const ipResp = JSON.parse(resp);
|
|
const ipLatitude = ipResp.geo.latitude;
|
|
const ipLongitude = ipResp.geo.longitude;
|
|
|
|
const insertQuery = await getConnection(Global.network)
|
|
.query(`INSERT INTO public.peer_ip(ip, longitude, latitude) VALUES ('${ips}', '${ipLongitude}', '${ipLatitude}');`);
|
|
|
|
// let mapMarker = {
|
|
// "type": "Feature",
|
|
// "geometry": {
|
|
// "type": "Point",
|
|
// "coordinates": [ipLongitude, ipLatitude]
|
|
// }
|
|
// }
|
|
const mapMarker = {
|
|
"longitude": ipLongitude,
|
|
"latitude": ipLatitude
|
|
};
|
|
|
|
markers.push(mapMarker);
|
|
users.locations = markers;
|
|
fs.writeFile(path.join(__dirname, "../../", "browser", "assets/geojson.json"), JSON.stringify(users), err => {
|
|
// Checking for errors
|
|
if (err) { throw err; }
|
|
});
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'Peers list fetched successfully',
|
|
response: {
|
|
dataJson: result
|
|
},
|
|
});
|
|
// http.get(peer_url,
|
|
// async (resp) => {
|
|
// // console.log('resp resp respresp',resp);
|
|
// let data = '';
|
|
// let result ;
|
|
|
|
// // A chunk of data has been recieved.
|
|
// await new Promise((resolve) => {
|
|
// resp.on('data', function (chunk) {
|
|
// data += chunk;
|
|
|
|
// let dataJson = self.IsJsonString(data);
|
|
// if(dataJson.length > 0){
|
|
|
|
// result = dataJson.map(function (value, i) {
|
|
// value['id'] = i;
|
|
// return value;
|
|
// });
|
|
// }
|
|
// resolve();
|
|
// });
|
|
// });
|
|
// response.status(200).json({
|
|
// status: 200,
|
|
// timestamp: Date.now(),
|
|
// message: 'Peers list fetched successfully',
|
|
// response: {
|
|
// dataJson: result
|
|
// },
|
|
// });
|
|
// });
|
|
} catch (error) {
|
|
console.log('error 3###########', error);
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
*/
|
|
|
|
private getPeers = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
var self = this;
|
|
try {
|
|
if(Global.network == "Floonet"){
|
|
var peer_url = process.env.FLOONET_PEER_URL;
|
|
}else{
|
|
var peer_url = process.env.TESTNET_PEER_URL;
|
|
}
|
|
let finalresult = await request_promise(peer_url);
|
|
if(finalresult){
|
|
var jsonresponse = JSON.parse(finalresult);
|
|
}
|
|
let result = jsonresponse.map(function (value, i) {
|
|
value['id'] = i;
|
|
return value;
|
|
});
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'Peers list fetched successfully',
|
|
response: {
|
|
dataJson: result
|
|
},
|
|
});
|
|
// http.get(peer_url,
|
|
// async (resp) => {
|
|
// // console.log('resp resp respresp',resp);
|
|
// let data = '';
|
|
// let result ;
|
|
|
|
// // A chunk of data has been recieved.
|
|
// await new Promise((resolve) => {
|
|
// resp.on('data', function (chunk) {
|
|
// data += chunk;
|
|
|
|
// let dataJson = self.IsJsonString(data);
|
|
// if(dataJson.length > 0){
|
|
|
|
// result = dataJson.map(function (value, i) {
|
|
// value['id'] = i;
|
|
// return value;
|
|
// });
|
|
// }
|
|
// resolve();
|
|
// });
|
|
// });
|
|
// response.status(200).json({
|
|
// status: 200,
|
|
// timestamp: Date.now(),
|
|
// message: 'Peers list fetched successfully',
|
|
// response: {
|
|
// dataJson: result
|
|
// },
|
|
// });
|
|
// });
|
|
} catch (error) {
|
|
console.log('error 3###########', error);
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
|
|
|
|
private TransactionFee = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
const TransactionFeeRequestData: TransactionFeeDto = request.query;
|
|
if (TransactionFeeRequestData.Interval) {
|
|
var timeIntervalQry =
|
|
"timestamp > current_date - interval '" +
|
|
TransactionFeeRequestData.Interval +
|
|
"'";
|
|
} else if (
|
|
TransactionFeeRequestData.FromDate ||
|
|
TransactionFeeRequestData.ToDate
|
|
) {
|
|
let fromdate = moment(TransactionFeeRequestData.FromDate)
|
|
.utc()
|
|
.format('YYYY-MM-DD');
|
|
let todate = moment(TransactionFeeRequestData.ToDate)
|
|
.utc()
|
|
.format('YYYY-MM-DD');
|
|
|
|
var timeIntervalQry =
|
|
"timestamp at time zone '" +
|
|
process.env.TIME_ZONE +
|
|
"' BETWEEN SYMMETRIC '" +
|
|
fromdate +
|
|
"' AND '" +
|
|
todate +
|
|
"'";
|
|
} else {
|
|
var timeIntervalQry = "timestamp > current_date - interval '30 days'";
|
|
}
|
|
const TransactionFeeQuery = await getConnection(Global.network)
|
|
.query(
|
|
"select 1 as hash, date(DATE_TRUNC('day', timestamp)) as date, avg(fee)/1000000000 as fee \
|
|
from blockchain_block t1 join blockchain_kernel t2 on t2.block_id=t1.hash where fee > 0 and " +
|
|
timeIntervalQry +
|
|
"group by DATE_TRUNC('day', timestamp) order by date",
|
|
)
|
|
.catch(err_msg => {
|
|
next(err_msg);
|
|
});
|
|
let date = [],
|
|
Fee = [];
|
|
TransactionFeeQuery.forEach(e => {
|
|
date.push(moment(e.date).format('YYYY-MM-DD'));
|
|
Fee.push(e.fee);
|
|
});
|
|
|
|
if (date.length == 0) {
|
|
date = [moment(Date.now()).format('YYYY-MM-DD')];
|
|
Fee = [0];
|
|
}
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'Transaction fee chart fetched successfully',
|
|
response: {
|
|
Date: date,
|
|
Fee: Fee,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
|
|
private HeatmapChart = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
// const TransactionFeeRequestData: TransactionFeeDto = request.query;
|
|
// if (TransactionFeeRequestData.Interval) {
|
|
// var timeIntervalQry =
|
|
// "timestamp > current_date - interval '" +
|
|
// TransactionFeeRequestData.Interval +
|
|
// "'";
|
|
// } else if (
|
|
// TransactionFeeRequestData.FromDate ||
|
|
// TransactionFeeRequestData.ToDate
|
|
// ) {
|
|
let fromdate = moment()
|
|
.subtract(7, 'd')
|
|
.format('YYYY-MM-DD');
|
|
let todate = moment()
|
|
.subtract(1, 'd')
|
|
.format('YYYY-MM-DD');
|
|
|
|
// var timeIntervalQry =
|
|
// 'timestamp BETWEEN SYMMETRIC ' + fromdate + ' AND ' + todate;
|
|
// } else {
|
|
// var timeIntervalQry = "timestamp > current_date - interval '30 days'";
|
|
// }
|
|
const TransactionHeatmapChartQuery = await getConnection(Global.network)
|
|
.query(
|
|
"with hours as ( \
|
|
SELECT generate_series('" +
|
|
fromdate +
|
|
" 00:00:00'::timestamp, '" +
|
|
todate +
|
|
" 23:00:00', '1 hours') as hour ) select hours.hour, t1.totalinput, t1.totalkernal, t1.totaloutput \
|
|
from hours left join(select to_char(x.timestamp,'YYYY-MM-DD HH24:00:00') as hour_of_day ,\
|
|
SUM(x.input_count) as totalinput, SUM(x.kernal_count) as totalkernal, SUM(x.output_count) as totaloutput\
|
|
from ( SELECT blockchain_block.hash, \
|
|
blockchain_block.timestamp, \
|
|
sum(bi.block_id_count) AS input_count,\
|
|
sum(bk.block_id_count) AS kernal_count, \
|
|
sum(bo.block_id_count) AS output_count \
|
|
FROM blockchain_block \
|
|
LEFT JOIN (select block_id, count(block_id) as block_id_count from blockchain_input group by block_id) as bi \
|
|
ON blockchain_block.hash = \
|
|
bi.block_id \
|
|
LEFT JOIN (select block_id, count(block_id) as block_id_count from blockchain_kernel where features != 'Coinbase' group by block_id) as bk \
|
|
ON blockchain_block.hash = \
|
|
bk.block_id \
|
|
LEFT JOIN (select block_id, count(block_id) as block_id_count from blockchain_output where output_type != 'Coinbase' group by block_id) as bo \
|
|
ON blockchain_block.hash = \
|
|
bo.block_id WHERE blockchain_block.timestamp >= '" +
|
|
fromdate +
|
|
" 00:00:00' \
|
|
AND blockchain_block.timestamp <= '" +
|
|
todate +
|
|
" 23:59:59' \
|
|
GROUP BY blockchain_block.hash \
|
|
ORDER BY blockchain_block.timestamp DESC ) as x \
|
|
group by to_char(x.timestamp,'YYYY-MM-DD HH24:00:00') \
|
|
order by hour_of_day asc) as t1 on to_timestamp(t1.hour_of_day, 'YYYY-MM-DD HH24:00:00') = hours.hour",
|
|
)
|
|
.catch(err_msg => {
|
|
next(err_msg);
|
|
});
|
|
let date = [],
|
|
hour = [],
|
|
totalinput = [],
|
|
totalkernal = [],
|
|
totaloutput = [],
|
|
innerhour = [],
|
|
innertotalinput = [],
|
|
innertotalkernal = [],
|
|
innertotaloutput = [],
|
|
prev_date = '';
|
|
|
|
// for(var i=0 ; i < 7 ; i++){
|
|
// date.push(moment().subtract(7, 'days').add(i, 'days').format('YYYY-MM-DD'));
|
|
// }
|
|
|
|
TransactionHeatmapChartQuery.forEach(e => {
|
|
var dateformat = moment(e.hour)
|
|
.format('YYYY-MM-DD HH')
|
|
.split(' ');
|
|
|
|
if (date.indexOf(dateformat[0]) >= 0 && prev_date == dateformat[0]) {
|
|
innerhour.push(dateformat[1]);
|
|
innertotalinput.push(e.totalinput != null ? e.totalinput : 0);
|
|
innertotalkernal.push(e.totalkernal != null ? e.totalkernal : 0);
|
|
innertotaloutput.push(e.totaloutput != null ? e.totaloutput : 0);
|
|
} else {
|
|
date.push(dateformat[0]);
|
|
innerhour.length > 0 ? hour.push(innerhour) : '';
|
|
innertotalinput.length > 0 ? totalinput.push(innertotalinput) : '';
|
|
innertotalkernal.length > 0 ? totalkernal.push(innertotalkernal) : '';
|
|
innertotaloutput.length > 0 ? totaloutput.push(innertotaloutput) : '';
|
|
(innerhour = []),
|
|
(innertotalinput = []),
|
|
(innertotalkernal = []),
|
|
(innertotaloutput = []);
|
|
innerhour.push(dateformat[1]);
|
|
innertotalinput.push((e.totalinput! = null ? e.totalinput : 0));
|
|
innertotalkernal.push(e.totalkernal != null ? e.totalkernal : 0);
|
|
innertotaloutput.push(e.totaloutput != null ? e.totaloutput : 0);
|
|
prev_date = dateformat[0];
|
|
}
|
|
});
|
|
hour.push(innerhour);
|
|
totalinput.push(innertotalinput);
|
|
totalkernal.push(innertotalkernal);
|
|
totaloutput.push(innertotaloutput);
|
|
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'Transaction heatmap chart fetched successfully',
|
|
response: {
|
|
date,
|
|
hour,
|
|
totalinput,
|
|
totalkernal,
|
|
totaloutput,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
|
|
private TransactionChart = async (
|
|
request: Request,
|
|
response: Response,
|
|
next: NextFunction,
|
|
) => {
|
|
try {
|
|
const TransactionFeeRequestData: TransactionFeeDto = request.query;
|
|
if (TransactionFeeRequestData.Interval) {
|
|
var timeIntervalQry =
|
|
"blockchain_block.timestamp > current_date - interval '" +
|
|
TransactionFeeRequestData.Interval +
|
|
"'";
|
|
var seriesquery =
|
|
"now() - interval '" +
|
|
TransactionFeeRequestData.Interval +
|
|
"', now()";
|
|
} else if (
|
|
TransactionFeeRequestData.FromDate ||
|
|
TransactionFeeRequestData.ToDate
|
|
) {
|
|
// var timeIntervalQry =
|
|
// 'blockchain_block.timestamp BETWEEN SYMMETRIC ' +
|
|
// TransactionFeeRequestData.FromDate +
|
|
// ' AND ' +
|
|
// TransactionFeeRequestData.ToDate;
|
|
|
|
var timeIntervalQry =
|
|
"blockchain_block.timestamp at time zone '" +
|
|
process.env.TIME_ZONE +
|
|
"' BETWEEN SYMMETRIC '" +
|
|
TransactionFeeRequestData.FromDate +
|
|
"' AND '" +
|
|
TransactionFeeRequestData.ToDate +
|
|
"'";
|
|
|
|
var seriesquery =
|
|
"'" +
|
|
TransactionFeeRequestData.FromDate +
|
|
"'::timestamp, '" +
|
|
TransactionFeeRequestData.ToDate +
|
|
"'";
|
|
} else {
|
|
var timeIntervalQry =
|
|
"blockchain_block.timestamp > current_date - interval '30 days'";
|
|
var seriesquery = "now() - interval '30 days', now()";
|
|
}
|
|
const TransactionHeatmapChartQuery = await getConnection(Global.network)
|
|
.query(
|
|
'with hours as ( SELECT hour::date from generate_series(' +
|
|
seriesquery +
|
|
", '1 day') as hour) select hours.hour, \
|
|
t1.totalinput, \
|
|
t1.totalkernal, \
|
|
t1.totaloutput \
|
|
from hours left join(select to_char(x.timestamp,'YYYY-MM-DD') as hour_of_day , \
|
|
SUM(x.input_count) as totalinput, SUM(x.kernal_count) as totalkernal, SUM(x.output_count) as totaloutput \
|
|
from ( SELECT blockchain_block.hash, \
|
|
blockchain_block.timestamp, \
|
|
sum(bi.block_id_count) AS input_count,\
|
|
sum(bk.block_id_count) AS kernal_count, \
|
|
sum(bo.block_id_count) AS output_count \
|
|
FROM blockchain_block \
|
|
LEFT JOIN (select block_id, count(block_id) as block_id_count from blockchain_input group by block_id) as bi \
|
|
ON blockchain_block.hash = \
|
|
bi.block_id \
|
|
LEFT JOIN (select block_id, count(block_id) as block_id_count from blockchain_kernel where features != 'Coinbase' group by block_id) as bk \
|
|
ON blockchain_block.hash = \
|
|
bk.block_id \
|
|
LEFT JOIN (select block_id, count(block_id) as block_id_count from blockchain_output where output_type != 'Coinbase' group by block_id) as bo \
|
|
ON blockchain_block.hash = \
|
|
bo.block_id WHERE " +
|
|
timeIntervalQry +
|
|
" \
|
|
GROUP BY blockchain_block.hash \
|
|
ORDER BY blockchain_block.timestamp DESC) as x \
|
|
group by to_char(x.timestamp,'YYYY-MM-DD') \
|
|
order by hour_of_day asc) as t1 on to_timestamp(t1.hour_of_day, 'YYYY-MM-DD') = hours.hour",
|
|
)
|
|
.catch(err_msg => {
|
|
next(err_msg);
|
|
});
|
|
let date = [],
|
|
totalinput = [],
|
|
totalkernal = [],
|
|
totaloutput = [];
|
|
|
|
TransactionHeatmapChartQuery.forEach(e => {
|
|
if (moment(e.hour).format('YYYY-MM-DD') >= moment('2019-09-03').format('YYYY-MM-DD')) {
|
|
date.push(moment(e.hour).format('YYYY-MM-DD'));
|
|
totalinput.push(e.totalinput != null ? e.totalinput : 0);
|
|
totalkernal.push(e.totalkernal != null ? e.totalkernal : 0);
|
|
totaloutput.push(e.totaloutput != null ? e.totaloutput : 0);
|
|
}
|
|
});
|
|
|
|
response.status(200).json({
|
|
status: 200,
|
|
timestamp: Date.now(),
|
|
message: 'Transaction chart fetched successfully',
|
|
response: {
|
|
date,
|
|
totalinput,
|
|
totalkernal,
|
|
totaloutput,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
next(new InternalServerErrorException(error));
|
|
}
|
|
};
|
|
}
|