async _getAlertsPage()

in source/services/api/event/lib/event.js [450:544]
80 lines of code
13 McCabe index (conditional complexity)

  async _getAlertsPage(userId, alertLevel, lastevalkey, deviceId, length, recursive) {
    // Gets whole alerts
    let _keyConditionExpression = 'userId = :uid';
    let _expressionAttributeValues = {
      ':uid': userId,
      ':false': false,
    };
    let _expressionAttributeNames = {
      '#ack': 'ack',
      '#type': 'type',
    };
    let _filterExpression = '#ack = :false';

    // FilterExpression for alert level
    // If user choose nothing for the alert level, return empty result.
    if (alertLevel.length > 0) {
      let _filterAlert = '';
      for (let i = 0; i < alertLevel.length; i++) {
        let alert = alertLevel[i];
        _expressionAttributeValues[`:${alert}`] = alert;

        if (i === 0) {
          _filterAlert = `#type = :${alert}`;
        } else {
          _filterAlert = `${_filterAlert} or #type = :${alert}`
        }
      }
      _filterExpression = `${_filterExpression} and (${_filterAlert})`;
    } else {
      return Promise.resolve({
        Items: [],
        deviceId: deviceId,
      })
    }

    // FilterExpression for the device ID
    if (deviceId !== undefined
      && deviceId.trim() !== '') {
      _filterExpression = `${_filterExpression} and deviceId = :deviceId`
      _expressionAttributeValues[':deviceId'] = deviceId.trim();
    }

    let params = this.commonUtils.generateDynamoDBQueryParams(
      process.env.EVENTS_TBL,
      _keyConditionExpression,
      _expressionAttributeValues,
      _expressionAttributeNames,
      _filterExpression,
      'userId-timestamp-index',
      false,
      lastevalkey
    );

    let alerts = [];
    let docClient = new AWS.DynamoDB.DocumentClient(this.dynamoConfig);
    try {
      let result = await docClient.query(params).promise();
      alerts = result.Items;
      length += alerts.length;

      // In case the result is less than 20 in total due to FilterExpression, call the method again with LastEvaluatedKey.
      if (length < 20
        && result.LastEvaluatedKey) {
        lastevalkey = result.LastEvaluatedKey;
        try {
          let data = await this._getAlertsPage(userId, alertLevel, lastevalkey, deviceId, length, true);
          alerts = [...alerts, ...data.Items];
          result.LastEvaluatedKey = data.LastEvaluatedKey;
        } catch (err) {
          return Promise.reject(err);
        }
      }

      // If recursive is false, add device name to the result.
      if (!recursive) {
        alerts = await this._putDeviceName(userId, alerts);
      }

      result.Items = alerts;
      result.deviceId = deviceId;

      return Promise.resolve(result);
    } catch (err) {
      Logger.error(Logger.levels.INFO, err);
      Logger.error(
        Logger.levels.INFO,
        `Error occurred while attempting to retrieve event alerts.`
      );
      return Promise.reject({
        code: 500,
        error: 'AlertQueryFailure',
        message: `Error occurred while attempting to retrieve event alerts.`,
      });
    }
  }