Source: models/assetsgroups.js

/**
 * Class handles asset related information and offers methods for dealing with assets in core database
 * @class
 */
class assetgroups {
  /**
   * @constructor
   * @param {object} alogger Logger to be used by class methods (usually req.app.logger)
   */
  constructor(alogger) {
    // always initialize all instance properties
    this._logger = alogger;
  }

  /**
   * Returns asset group as row from core database
   * @param {integer} aId 
   * @param {function} callback row or null
   */
  getAssetGroup(aId, callback) {
    let query = "SELECT * FROM `assets_groups` WHERE id = ?";
    global.coreDb.all(query, [
      aId
    ], (err, rows) => {
      if (err) {
        this._logger.error('MODELS-ASSETSGROUPS | Error loading assets group from core database:' + err.message);
        return callback(null);
      } else {
        return callback(rows);
      }
    });
  }

  /**
   * Returns rows for all existing asset groups in core database
   * @param {function} callback rows or null
   */
  getListOfAssetGroups(callback) {
    this._logger.debug('MODELS-ASSETGROUPS | Reading asset groups');

    let query = "SELECT assets_groups.*, " +
      "roles.rolename AS rolename, " +
      "roles.id AS roleId, " +
      "organizations.id AS organizationId, " +
      "organizations.name AS organizationName " +
      "FROM `assets_groups` " +
      "INNER JOIN roles ON assets_groups.responsibleRoleId = roles.id " +
      "INNER JOIN organizations ON assets_groups.organizationId = organizations.id";

    global.coreDb.all(query, [], (err, rows) => {
      if (err) {
        this._logger.error('MODELS-ASSETSGROUPS | Error loading assets groups from core database:' + err.message);
        return callback(null);
      } else {
        return callback(rows);
      }
    });
  }

  /**
   * Returns assets groups limited to a singel organization
   * @param {integer} orgId id of organization assets groups shall be returned
   * @param {function} callback rows or null
   */
  getListOfAssetGroupsForOrganization(orgId, callback) {
    this._logger.debug('MODELS-ASSETGROUPS | Reading asset groups');

    let query = "SELECT assets_groups.*, " +
      "roles.rolename AS rolename, " +
      "roles.id AS roleId, " +
      "organizations.id AS organizationId, " +
      "organizations.name AS organizationName " +
      "FROM `assets_groups` " +
      "INNER JOIN roles ON assets_groups.responsibleRoleId = roles.id " +
      "INNER JOIN organizations ON assets_groups.organizationId = organizations.id " +
      "WHERE assets_groups.organizationId = ?";

    global.coreDb.all(query, [
      orgId
    ], (err, rows) => {
      if (err) {
        this._logger.error(`MODELS-ASSETSGROUPS | Error loading assets groups for organization with id ${orgId} from core database:${err.message}`);
        return callback(null);
      } else {
        return callback(rows);
      }
    });
  }

  /**
   * Checks if an asset group name for organization given in organizationId exists in core database
   * @param {string} groupname name of group to check 
   * @param {integer} organizationId id of organization to check for
   * @param {function} callback success (true = exists, false = does not exist)
   */
  doesGroupExistForOrganization(groupname, organizationId, callback) {
    let query = "SELECT * FROM assets_groups WHERE name = ? AND organizationId = ?";
    global.coreDb.all(query, [
      groupname,
      organizationId
    ], (err, rows) => {
      if (err) {
        this._logger.error(`MODELS-ASSETSGROUPS | Error loading assets groups for organization with id ${organizationId} from core database:${err.message}`);
        return callback(false);
      } else {
        if (rows.length > 0) {
          return callback(true);
        } else {
          return callback(false);
        }
      }
    });
  }

  /**
   * Adds a new assets group to core database if not existing for the given organization id with given name
   * @param {object} reqBody form body containing the form fields data (usually req.body)
   * @param {function} callback success (true or false)
   */
  addAssetsGroup(reqBody, callback) {
    let message = '';
    let groupname = reqBody.groupname;
    let organizationId = reqBody.orgId;
    let roleid = reqBody.roleid;
    let isGearGroup = reqBody.isGearGroup;
    if (isGearGroup === 'on') {
      isGearGroup = 1;
    } else {
      isGearGroup = 0;
    }


    this.doesGroupExistForOrganization(groupname, organizationId, (success) => {
      if (success) {
        // groupname exists for organization --> don't add it
        message = 'Groupname already exists';
        res.render('/assets/group_add.ejs', {
          message,
          navarea: 'assets',
          avatarpath: req.session.avatar,
          name: req.session.name,
          organizationname: req.session.organization,
          title: 'Welcome to Socka | Add a new Group'
        });
      } else {
        // Groupname does not exist for organization. Go on and add the new group
        let query = "INSERT INTO `assets_groups` (name, responsibleRoleId, organizationId, isGearGroup) VALUES (?, ?, ?, ?)";
        global.coreDb.run(query,
          [
            groupname,
            roleid,
            organizationId,
            isGearGroup
          ],
          function (err) {
            if (err) {
              console.log('ERROR Adding new assets group enty to core database: ' + err.message);
              callback(false);
            } else {
              console.log('Successfully added new assets group enty to core database');
              callback(true);
            }
          });
      }
    })
  }

  /**
   * 
   * @param {object} reqBody form body containing the form fields data (usually req.body)
   * @param {integer} aId id of assets group to be updated
   * @param {function} callback success (true or false)
   */
  editAssetsGroup(reqBody, aId, callback) {
    let roleId = reqBody.roleid;
    let groupName = reqBody.groupname;
    let orgId = reqBody.orgId;
    let isGearGroup = reqBody.isGearGroup;
    if (isGearGroup === 'on') {
      isGearGroup = 1;
    } else {
      isGearGroup = 0;
    }

    let query = "UPDATE `assets_groups` SET `name` = ?, responsibleRoleId = ?, organizationId = ?, isGearGroup = ?  WHERE id = ?";
    global.coreDb.run(query,
      [
        groupName,
        roleId,
        orgId,
        isGearGroup,
        aId
      ],
      function (err) {
        if (err) {
          console.log('ERROR Updating assets group enty to core database: ' + err.message);
          callback(false);
        } else {
          callback(true);
        }
      });    
  }

  /**
   * deletes an assets group from database
   * @param {integer} id 
   * @param {function} callback success (true / false) 
   */
  deleteGroup(id, callback) {
    let query = "DELETE FROM assets_groups WHERE id = ?";
    global.coreDb.run(query,
      [
        id
      ],
      function (err) {
        if (err) {
          console.log('ERROR Deleting assets group enty from core database: ' + err.message);
          callback(false);
        } else {
          callback(true);
        }
      });  
  }


}

// export the class
module.exports = assetgroups;