async deleteDevice()

in source/services/api/device/lib/device.js [200:303]
80 lines of code
11 McCabe index (conditional complexity)

  async deleteDevice(ticket, deviceId) {
    let ddbEmpty = false;
    let iotEmpty = false;

    try {
      // Gets device from DDB and delete from DDB
      let data = await this._getDevice(ticket.sub, deviceId);
      if (!_.isEqual(data, {})) {
        let device = data.Item;
        device.updatedAt = moment().utc().format();
        device.status = 'deleted'

        let params = {
          TableName: process.env.REGISTRATION_TBL,
          Item: device,
        };

        const docClient = new AWS.DynamoDB.DocumentClient(this.dynamoConfig);
        await docClient.put(params).promise();
      } else {
        ddbEmpty = true;
      }

      // Gets device from IoT and delete from IoT
      let iotData = await this._getIotDevice(ticket.sub, deviceId);
      if (!_.isEqual(iotData, {})) {
        let params = {
          thingName: deviceId,
        };

        const iot = new AWS.Iot({
          region: process.env.AWS_REGION,
        });

        // Step 1. Get thing principals
        let result = await iot.listThingPrincipals(params).promise();
        let principals = result.principals;

        for (let i = 0; i < principals.length; i++) {
          let principal = principals[i];
          if (principal.indexOf('cert/') > -1) {
            let certificateId = principal.substring(
              principal.indexOf('cert/') + 5,
              principal.length
            );
            
            // Step 2. Detach thing principals
            await iot.detachThingPrincipal({
              principal: principals[i],
              thingName: deviceId
            }).promise();

            // Step 3. Update certificate
            await iot.updateCertificate({
              certificateId: certificateId,
              newStatus: 'INACTIVE'
            }).promise();

            // Step 4. Delete certificate
            await iot.deleteCertificate({
              certificateId: certificateId,
              forceDelete: true
            }).promise();

            // Step 5. Delete policy
            await iot.deletePolicy({
              policyName: certificateId
            }).promise();
          }
        }

        // Step 6. Delete thing
        await iot.deleteThing(params).promise();
      } else {
        iotEmpty = true;
      }

      if (ddbEmpty && iotEmpty) {
        return Promise.reject({
          code: 400,
          error: 'MissingDevice',
          message: `The device "${deviceId}" does not exist.`
        });
      }

      return Promise.resolve('Delete successful');
    } catch (err) {
      if (err.error == 'MissingDevice') {
        return Promise.reject(err);
      }

      Logger.error(Logger.levels.INFO, err);
      Logger.error(
        Logger.levels.INFO,
        `[DeviceDeleteFailure] Error occurred while attempting to delete device ${deviceId}.`
      );

      return Promise.reject({
        code: 500,
        error: 'DeviceDeleteFailure',
        message: `Error occurred while attempting to delete device "${deviceId}".`,
      });
    }
  }