@bowtie/sls/src/models/Submission.js

Serverless helpers & utilities

const AWS = require('aws-sdk');
const uuidv1 = require('uuid/v1')
// const merge = require('deepmerge')
const { verifySchema } = require('@bowtie/utils')
const { dynamoose, defaults, helpers } = require('../config')
const { parseServiceConfig, scanRecursive, findDeploymentHost, findDeploymentLinks } = require('../utils')
const pubnub = require('../pubnub')
// [HIGH] TODO: WTF?!?
// const Audit = require('./Audit')

const { Schema } = dynamoose
const { envGetAlias, tagIsRelease } = helpers

const DEFAULT_FILEPATH = 'submissions';

const SubmissionSchema = new Schema({
  id: {
    type: String,
    required: true,
    hashKey: true,
    default: (model) => uuidv1()
  },
  timestamp: {
    type: Number,
    // index: true,
    required: true,
    // rangeKey: true,
    default: (model) => Date.now()
  },
  documentId: {
    type: String,
    required: false,
  },
  secure: {
    type: Boolean,
    default: false
  },
  viewed: {
    type: Boolean,
    default: false
  },
  verified: {
    type: Boolean,
    default: false
  },
  archived: {
    type: Boolean,
    default: false
  },
  lifetime: {
    type: Number,
    required: true,
    default: 30
  },
  getObjectUrl: String,
  putObjectUrl: String,
  filepath: {
    type: String,
    default: DEFAULT_FILEPATH,
  },
  filename: String,
  filetype: String,
  filesize: Number,
  formData: Object,
  metaData: Object,
  sourceIp: String,
  userAgent: String
}, {
  timestamps: true,
  throughput: 'ON_DEMAND'
})

const SubmissionModel = dynamoose.model(process.env.SUBMISSIONS_TABLE_NAME, SubmissionSchema);

SubmissionModel.methods.set('scanAll', async function (params = {}) {
  return scanRecursive(this, params)
})

SubmissionModel.methods.document.set('publish', function (data = {}, action = 'saved') {
  return new Promise(
    (resolve, reject) => {
      const payload = {
        channel: 'submissions',
        message: {
          data,
          action,
          service: process.env.SERVICE_NAME,
          subject: this
        }
      }

      console.log('Submission publish', { payload, data }, this)

      if (pubnub) {
        pubnub.publish(payload, (status, response) => {
          console.log('PN Publish', { status, response })

          if (status.error) {
            const { operation, statusCode } = status
            reject(new Error(`FAIL: Submission#publish() failed: (${operation} -> ${statusCode}})`))
          } else {
            resolve(this)
          }
        })
      } else {
        console.log('PubNub is not configured, not publishing updates')

        resolve(this)
      }
    }
  )
})

SubmissionModel.methods.document.set('saveNotify', async function (options = {}) {
  const Document = require('./Document')

  if (this.filename && this.filetype) {
    if (!this.filepath) {
      this.filepath = DEFAULT_FILEPATH
    }

    this.getObjectUrl = await this.getSignedUrl('getObject');

    if (!this.putObjectUrl) {
      this.putObjectUrl = await this.getSignedUrl('putObject');
    }

    if (this.verified && !this.documentId) {
      const { filename, filetype, filesize, filepath } = this;

      const newDocument = await new Document({
        filename,
        filetype,
        filesize,
        filepath,
        permissions: {
          allow: [ 'admin' ],
          deny: [ 'read', 'write' ]
        }
      })

      await newDocument.saveNotify()

      this.documentId = newDocument.id
    }
  }

  const data = await this.save()
  return await this.publish(data, 'saved')
})

SubmissionModel.methods.document.set('getSignedUrl', async function (operation = 'getObject') {
  // AWS.config.update({region: 'us-east-1'});

  const s3 = new AWS.S3({
    signatureVersion: 'v4'
  });

  const params = this.signedUrlParams();

  if (operation === 'putObject') {
    params.ContentType = this.filetype;
  }

  console.log('INFO: Submission.getSignedUrl()', { params });

  const signedUrl = await s3.getSignedUrlPromise(operation, params)

  console.log('INFO: Submission.getSignedUrl()', { signedUrl });

  return signedUrl;
})

SubmissionModel.methods.document.set('signedUrlParams', function (options = {}) {
  const Bucket = process.env.SECURE_BUCKET_NAME;
  const Key = `${this.filepath}/${this.filename}`.replace(/\/+/g, '/').replace(/\s/g, '_');
  const Expires = this.lifetime;
  // const ContentType = this.filetype;

  return ({
    Expires,
    Bucket,
    Key,
    // ContentType,
  });
});


module.exports = SubmissionModel