async createRegistration()

in source/services/api/registration/lib/registration.js [127:256]
91 lines of code
16 McCabe index (conditional complexity)

  async createRegistration(ticket, registration) {
    const {deviceId, deviceName, modelNumber} = registration;
    let docClient = new AWS.DynamoDB.DocumentClient(this.dynamoConfig);
    let errors = [
      'DeviceNotFoundFailure',
      'DeviceRegisteredFailure',
      'RetrieveReferenceFailure',
      'RetrieveRegistrationFailure',
      'CreateThingFailure',
      'DeviceRollBackFailure'
    ];

    try {
      // 1. Checks if the device ID and model number is valid.
      let reference = await this._getReference(deviceId, modelNumber);
      if (_.isEqual(reference, {})) {
        return Promise.reject({
          code: 400,
          error: 'DeviceNotFoundFailure',
          message: `Manufacturer info cannot be found for serial number "${deviceId}" and model number "${
            modelNumber}". Please add a model number/serial number that is supported by the manufacturer.`
        });
      }
      let {details} = reference.Item;

      // 2. Checks if the device is already registered.
      let isDeviceRegistered = await this._isDeviceRegistered(deviceId);
      if (isDeviceRegistered) {
        return Promise.reject({
          code: 500,
          error: 'DeviceRegisteredFailure',
          message: `Device with serial number "${deviceId}" has been already registered.`
        });
      }

      // 3. Puts an item into the DynamoDB table
      let _registration = {
        deviceId,
        deviceName,
        modelNumber,
        details,
        status: 'pending',
        userId: ticket.sub,
        createdAt: moment()
          .utc()
          .format(),
        updatedAt: moment()
          .utc()
          .format(),
      };

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

      await docClient.put(params).promise();

      // 4. Creates a thing
      try {
        await this._createThing(_registration);
      } catch (err) {
        // If error occurs while creating a thing, rollback DynamoDB.
        let params = {
          TableName: process.env.REGISTRATION_TBL,
          Key: {
            userId: ticket.sub,
            deviceId: deviceId,
          }
        };

        try {
          await docClient.delete(params).promise();
        } catch (err) {
          Logger.error(Logger.levels.INFO, err);
          Logger.error(
            Logger.levels.INFO,
            `[DeviceRollBackFailure] Error occurred while rolling back the device ${deviceId} registration.`
          );

          return Promise.reject({
            code: 500,
            error: 'DeviceRollBackFailure',
            message: `Error occurred while rolling back the device "${deviceId}" registration.`
          });
        }

        return Promise.reject(err);
      }

      // Sends anonymous metric data
      const anonymousData = process.env.anonymousData;
      const solutionId = process.env.solutionId;
      const solutionUuid = process.env.solutionUuid;

      if (anonymousData === 'true') {
        let metric = {
          Solution: solutionId,
          UUID: solutionUuid,
          Timestamp: moment().utc().format('YYYY-MM-DD HH:mm:ss.S'),
          Registrations: 1,
        };

        let usageMetrics = new UsageMetrics();
        try {
          await usageMetrics.sendAnonymousMetric(metric);
        } catch (e) {
          Logger.error(Logger.levels.INFO, e);
        }
      }

      return Promise.resolve(_registration);
    } catch (err) {
      // Handling existing errors
      if (errors.indexOf(err.error) > -1) {
        return Promise.reject(err);
      }

      Logger.error(Logger.levels.INFO, err);
      Logger.error(
        Logger.levels.INFO,
        `[RegistrationCreateFailure] Error occurred while attempting to create registration for device ${deviceId}.`
      );
      return Promise.reject({
        code: 500,
        error: 'RegistrationCreateFailure',
        message: `Error occurred while attempting to create registration for device "${deviceId}".`,
      });
    }
  }