constructor(public config: AWSConfig) {
   awsConfig.update({
     credentials: new Credentials(config.accessKeyId, config.secretAccessKey),
     region: config.region
   });
   this.db = new DynamoDB() as any;
 }

 private configureAWS(config:DeployConfig) {
   if (this.hasConfiguredAWS) {
     return;
   }
   this.hasConfiguredAWS = true;
   awsConfig.update({
     credentials: new Credentials(config.accessKeyId, config.secretAccessKey),
     region: config.region
   });
 }

 constructor(public config: S3Config) {
   awsConfig.update({
     credentials: new Credentials(config.accessKeyId, config.secretAccessKey),
     region: config.region
   });
   this.s3 = new S3({
     credentials: new Credentials(config.accessKeyId, config.secretAccessKey),
     region: config.region,
     bucket: config.bucket
   });
 }

  run(config:DeployConfig): Promise<any> {
    awsConfig.update({
      credentials: new Credentials(config.accessKeyId, config.secretAccessKey),
      region: config.region
    });

    return this.publish(config)
    .then((result:any[]) => {
      if (config.lambdaAlias) {
        return this.pointAlias(config, result);
      }
    });
  }

 _getAWS(params) {
   params = params || this.resources || {};
   params.accessKeyId = params.accessKeyId || process.env["AWS_ACCESS_KEY_ID"];
   params.secretAccessKey =
     params.secretAccessKey || process.env["AWS_SECRET_ACCESS_KEY"];
   params.sessionToken =
     params.sessionToken || process.env["AWS_SESSION_TOKEN"];
   params.region =
     params.region || process.env["AWS_DEFAULT_REGION"] || "us-east-1";
   AWS.config.update({
     accessKeyId: params.accessKeyId,
     secretAccessKey: params.secretAccessKey,
     sessionToken: params.sessionToken,
     region: params.region
   });
   return AWS;
 }

export function processGetAWS(request: GetAWSSignRequest, callback: (GetAWSSignResponse) => void) {
    aws.config.update({
        accessKeyId: AWS_ACCESS_KEY,
        secretAccessKey: AWS_SECRET_KEY,
        signatureVersion: 'v4',
        region: 'eu-central-1'
    });
    const s3 = new aws.S3();
    let extension = path.extname(request.fileName == null ? 'default.jpg' : request.fileName);

    const url = request.token + '/stage_' + request.stageId + '/quest_' + request.questId + '/f_' + new Date().getTime() + '_' + request.type + extension;
    const s3_params = {
        Bucket: S3_BUCKET,
        Key: url,
        Expires: 60,
        ContentType: request.fileType,
        ACL: 'public-read'
    };
    s3.getSignedUrl('putObject', s3_params, function (err, data) {
        let result: GetAWSSignResponse;
        if (err) {
            result = {
                success: false
            };
        }
        else {
            result = {
                sign: data,
                url: 'https://' + S3_BUCKET + '.s3.amazonaws.com/' + url,
                success: true

            };
        }
        callback(result);
    });
}

import {NinjaAccount, Account} from './ninjaAccount';
import {Promise} from 'es6-promise';
import * as AWS from 'aws-sdk';

const config = require('./UNconfig.json');

AWS.config.update({
    region: 'eu-west-1'
});

const d = (d0: number): number => new Date().getTime() - d0;

export function getRequestToken (event, context, callback) {
}

export function checkUnfollow (event, context, callback) {
    const d0 = new Date().getTime();
    if (!config.app_key || !config.app_secret)
        return callback(new Error('Please fill app_key and app_secret in UNconfig.json'));

    const ID = event.params.path.id;
    const q = new NinjaAccount(config, ID);
    q.checkUnfollow()
        .then((recap) => callback(null, {status: 'OK', recap: recap, duration: d(d0)}))
        .catch((err: Error) => callback(null, {status: 'error', message: err.message, duration: d(d0)}));
}

export function checkAll (event, context, cb) {
    const callback = (err, data?) => {
        if (err) console.log('error - ', err);
        console.log(data);

var iterating = false;

/**
 * Configure logging
 */
var logger = new (winston.Logger)({
  transports: [
    new (winston.transports.Console)({ level: 'debug' })
  ]
})

/**
 * Set up AWS
 */
AWS.config.update({region: 'us-east-1'});
var ddb = new AWS.DynamoDB.DocumentClient(),
    dynamo =  promise.promisifyAll(ddb);

/**
 * Functions for retrieving data from DB
 */

// get all items in the run number given a hash
// if following is true, get only future predictions from the timestamp
async function getAllOfRunNumber(hash, following) {
  // calculate a range of values. run numbers are per day,
  // so this gets us a list of all other predictions given the run number and a timestamp

  let unixTime = Number(hash.prdt) * 1000

 constructor({FIREBASECONFIG, AWSCONFIG}) {
   this.firebase = firebase.initializeApp(FIREBASECONFIG);
   this.database = this.firebase.database();
   this.registryBucket = AWSCONFIG.Bucket;
   config.update({ accessKeyId: AWSCONFIG["aws_access_key_id"], secretAccessKey: AWSCONFIG["aws_secret_access_key"], region: AWSCONFIG["region"]});
 };

/// <reference path="../_all.d.ts" />
"use strict";

import { config } from "./config";
import * as AWS from "aws-sdk";

AWS.config.update(config.database);

export var database = new AWS.DynamoDB.DocumentClient();