solid-server/lib/requests/delete-account-request.js

'use strict'

const AuthRequest = require('./auth-request')
const debug = require('./../debug').accounts

// class DeleteAccountRequest  {
class DeleteAccountRequest extends AuthRequest {
  constructor (options) {
    super(options)

    this.username = options.username
  }

  /**
   * Calls the appropriate form to display to the user.
   * Serves as an error handler for this request workflow.
   *
   * @param error {Error}
   */
  error (error) {
    error.statusCode = error.statusCode || 400

    this.renderForm(error)
  }

  /**
   * Returns a user account instance for the submitted username.
   *
   * @throws {Error} Rejects if user account does not exist for the username
   *
   * @returns {Promise<UserAccount>}
   */
  async loadUser () {
    let username = this.username

    return this.accountManager.accountExists(username)
      .then(exists => {
        if (!exists) {
          throw new Error('Account not found for that username')
        }

        let userData = { username }

        return this.accountManager.userAccountFrom(userData)
      })
  }

  /**
   * Renders the Delete form
   */
  renderForm (error) {
    this.response.render('account/delete', {
      error,
      multiuser: this.accountManager.multiuser
    })
  }

  /**
   * Displays the 'your reset link has been sent' success message view
   */
  renderSuccess () {
    this.response.render('account/delete-link-sent')
  }

  /**
   * Loads the account recovery email for a given user and sends out a
   * password request email.
   *
   * @param userAccount {UserAccount}
   *
   * @return {Promise}
   */
  async sendDeleteLink (userAccount) {
    let accountManager = this.accountManager

    const recoveryEmail = await accountManager.loadAccountRecoveryEmail(userAccount)
    userAccount.email = recoveryEmail

    debug('Preparing delete account email to:', recoveryEmail)

    return accountManager.sendDeleteAccountEmail(userAccount)
  }

  /**
   * Validates the request parameters, and throws an error if any
   * validation fails.
   *
   * @throws {Error}
   */
  validate () {
    if (this.accountManager.multiuser && !this.username) {
      throw new Error('Username required')
    }
  }

  static async post (req, res) {
    const request = DeleteAccountRequest.fromParams(req, res)

    debug(`User '${request.username}' requested to be sent a delete account email`)

    return DeleteAccountRequest.handlePost(request)
  }

  /**
   * Performs a 'send me a password reset email' request operation, after the
   * user has entered an email into the reset form.
   *
   * @param request {DeleteAccountRequest}
   *
   * @return {Promise}
   */
  static async handlePost (request) {
    try {
      request.validate()
      const userAccount = await request.loadUser()
      await request.sendDeleteLink(userAccount)
      return request.renderSuccess()
    } catch (error) {
      return request.error(error)
    }
  }

  static get (req, res) {
    const request = DeleteAccountRequest.fromParams(req, res)

    request.renderForm()
  }

  static fromParams (req, res) {
    let locals = req.app.locals
    let accountManager = locals.accountManager
    let username = this.parseParameter(req, 'username')

    let options = {
      accountManager,
      response: res,
      username
    }

    return new DeleteAccountRequest(options)
  }
}

module.exports = DeleteAccountRequest