import * as Koa from 'koa';
import * as KoaRouter from 'koa-trie-router';
import * as config from 'config';
import * as _mount from 'koa-mount';
const APP_CONFIG = config.get('app');
export class BaseHandler {
protected router: KoaRouter;
protected app: Koa;
public mount_path: string;
constructor(app: Koa, prefix) {
this.app = app;
this.mount_path = APP_CONFIG.namespace + prefix;
this.router = new KoaRouter(this.mount_path);
}
protected mount() {
this.app.use(_mount(this.mount_path, this.router.middleware()));
}
}
import * as config from 'config'
import { expect } from 'chai'
import { Request } from 'express'
import { JwtExtractor } from 'idam/jwtExtractor'
const sessionCookieName = config.get<string>('session.cookieName')
describe('Extracting JWT', () => {
it('should return token from cookie', () => {
const jwtValue = 'a'
const req = {
cookies: {
[sessionCookieName]: jwtValue
}
} as Request
expect(JwtExtractor.extract(req)).to.equal(jwtValue)
})
})
.get(Paths.mcolEligibilityPage.uri, (req: express.Request, res: express.Response): void => {
res.render(Paths.mcolEligibilityPage.associatedView, {
mcolUrl: config.get<string>('mcol.url')
})
})
.some((featureName) => toBoolean(config.get<boolean>(`featureToggles.${featureName}`)))
import Utils from './utils'
import Requests from './requests'
import * as config from 'config'
// get token from https://steamcommunity.com/saliengame/gettoken
// can add many user
const userList = config.get('token')
let singleton: boolean = false
if (userList.length === 1) {
singleton = true
}
function getRandomInt(min: number, max: number): number {
min = Math.ceil(min)
max = Math.floor(max)
return Math.floor(Math.random() * (max - min)) + min
}
async function SteamGame(userToken: string) {
let loggerName = `Saliens (${userToken})`
if (singleton) {
loggerName = `Saliens`
}
const logger = new Utils.Logger(Utils.Logger.LEVEL_INFO, loggerName)
const requests = new Requests.SalienGame(userToken, logger)
let times = 0
while (true) {
const bossPlanet = await requests.getBossPlanet()
'activitypub-http-fetcher': 1,
'video-file': 1,
'email': 5
}
// 2 days
const JOB_COMPLETED_LIFETIME = 60000 * 60 * 24 * 2
// 1 hour
let SCHEDULER_INTERVAL = 60000 * 60
// ---------------------------------------------------------------------------
const CONFIG = {
CUSTOM_FILE: getLocalConfigFilePath(),
LISTEN: {
PORT: config.get<number>('listen.port')
},
DATABASE: {
DBNAME: 'peertube' + config.get<string>('database.suffix'),
HOSTNAME: config.get<string>('database.hostname'),
PORT: config.get<number>('database.port'),
USERNAME: config.get<string>('database.username'),
PASSWORD: config.get<string>('database.password')
},
REDIS: {
HOSTNAME: config.get<string>('redis.hostname'),
PORT: config.get<number>('redis.port'),
AUTH: config.get<string>('redis.auth')
},
SMTP: {
HOSTNAME: config.get<string>('smtp.hostname'),
import * as Koa from 'koa';
import * as Router from 'koa-trie-router';
import * as bodyparser from 'koa-bodyparser';
import * as config from 'config';
import * as jwt from 'jsonwebtoken';
import * as mount from 'koa-mount';
import * as responseTime from 'koa-response-time';
import { UserService } from './routes/users/user.service';
import { BindRoutes } from './routes';
const APP_CONFIG = config.get('app');
const JWT_CONFIG = config.get('jwt');
const app = new Koa();
const userService = new UserService();
// X-Response-Time
app.use(responseTime());
// Body Parsing
app.use(bodyparser());
// 404 Handler
app.use(async (ctx, next) => {
await next();
if (ctx.status === 404) {
ctx.response.status = 404;
ctx.response.body = {
error: true,
message: 'Entity not found'
};
}
import * as config from 'config'
import * as express from 'express'
import * as _ from 'lodash'
import { Eligibility } from 'eligibility/model/eligibility'
const minuteInMilliseconds = 60 * 1000
const cookieTimeToLiveInMinutes = config.get<number>('eligibility.cookie.timeToLiveInMinutes') * minuteInMilliseconds
export const cookieName = 'eligibility-check'
export class CookieEligibilityStore {
read (req: express.Request, res: express.Response): Eligibility {
const cookie: string = req.cookies[cookieName]
return new Eligibility().deserialize(cookie !== undefined ? cookie : undefined)
}
write (eligibility: Eligibility, req: express.Request, res: express.Response): void {
const excludeDisplayValue = (value: any): any | undefined => {
const property = 'displayValue'
if (value && typeof value === 'object' && Object.getOwnPropertyDescriptor(value, property)) {
return _.omit(value, property)
}
return undefined
}
res.cookie(cookieName, _.cloneDeepWith(eligibility, excludeDisplayValue), { httpOnly: true, secure: true, maxAge: cookieTimeToLiveInMinutes })
}
clear (req: express.Request, res: express.Response): void {
res.clearCookie(cookieName)
import * as mock from 'nock'
import * as HttpStatus from 'http-status-codes'
import * as config from 'config'
const baseURL = config.get<string>('pay.url')
const endpointPath = '/card-payments'
const paymentsPath = '/payments'
export const paymentInitiateResponse: object = {
reference: 'RC-1520-4225-4161-2265',
date_created: '2018-03-07T11:35:42.095+0000',
status: 'Initiated',
_links: {
next_url: {
href: 'https://www.payments.service.gov.uk/secure/8b647ade-02cc-4c85-938d-4db560404df8',
method: 'GET'
}
}
}
const paymentRetrieveResponse: object = {
amount: 60,
description: 'Money Claim issue fee',
reference: 'RC-1520-4276-0065-8715',
currency: 'GBP',
ccd_case_number: 'UNKNOWN',
case_reference: 'dfd75bac-6d54-4c7e-98f7-50e047d7c7f5',
channel: 'online',
method: 'card',
external_provider: 'gov pay',
status: 'Success',
authenticate: (socket, data: {username: string, password: string}, callback) => {
return callback(null, data.password === config.get('webPass'))
}
