Code coverage report for app/mappers/alert_groups_mapper.js

Statements: 100% (40 / 40)      Branches: 68.18% (15 / 22)      Functions: 100% (6 / 6)      Lines: 100% (40 / 40)      Ignored: none     

All files » app/mappers/ » alert_groups_mapper.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122    1                                   1                 1                               3 1   3 3 3                                       3 6 6 6 6 6 6 27 27   27 27   27     6 6 12 12   12 9   12       6 6 6 6 2       3 3 3       3 3 3   3 3        
'use strict';
 
;require.register("mappers/alert_groups_mapper", function (exports, require, module) {
  /**
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements. See the NOTICE file distributed with this
   * work for additional information regarding copyright ownership. The ASF
   * licenses this file to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations under
   * the License.
   */
 
  var App = require('app');
 
  /**
   * Mapper for <code>App.AlertGroup</code>
   * Save general information
   * Doesn't save not changed data (check it using <code>App.cache['previousAlertGroupsFullMap']</code>)
   * Use <code>App.cache['previousAlertGroupsMap']</code> to store map alertDefinitions-alertGroups. This map is used
   * in the <code>App.AlertDefinitionsMapper</code> to correctly link alertDefinitions and alertGroups
   */
  App.alertGroupsMapper = App.QuickDataMapper.create({
 
    model: App.AlertGroup,
 
    config: {
      id: 'AlertGroup.id',
      name: 'AlertGroup.name',
      default: 'AlertGroup.default',
      targets_key: 'AlertGroup.targets',
      targets_type: 'array',
      targets: {
        item: 'id'
      }
    },
 
    map: function map(json, ignoreDelete) {
      if (Em.isNone(App.cache['previousAlertGroupsFullMap'])) {
        App.cache['previousAlertGroupsFullMap'] = {};
      }
      Eif (!Em.isNone(json, 'items')) {
        console.time('App.alertGroupsMapper execution time');
        var alertGroups = [],
            self = this,
            groupsMap = {},
            groupsToDelete = App.AlertGroup.find().mapProperty('id'),
 
        /**
         * AlertGroups-map for <code>App.AlertDefinitionsMappers</code>
         * Format:
         * <code>
         *   {
         *    alert_definition1_id: [alert_group1_id, alert_group2_id],
         *    alert_definition2_id: [alert_group3_id, alert_group1_id],
         *    ...
         *   }
         * </code>
         * @type {object}
         */
        alertDefinitionsGroupsMap = {},
            alertNotificationsGroupsMap = {};
 
        json.items.forEach(function (item) {
          var group = self.parseIt(item, self.get('config'));
          groupsToDelete = groupsToDelete.without(group.id);
          group.targets = [];
          group.definitions = [];
          Eif (item.AlertGroup.definitions) {
            item.AlertGroup.definitions.forEach(function (definition) {
              Eif (!group.definitions.contains(definition.id)) {
                group.definitions.push(definition.id);
              }
              Eif (Em.isNone(alertDefinitionsGroupsMap[definition.id])) {
                alertDefinitionsGroupsMap[definition.id] = [];
              }
              alertDefinitionsGroupsMap[definition.id].push(group.id);
            });
          }
          Eif (item.AlertGroup.targets) {
            item.AlertGroup.targets.forEach(function (target) {
              Eif (!group.targets.contains(target.id)) {
                group.targets.push(target.id);
              }
              if (Em.isNone(alertNotificationsGroupsMap[target.id])) {
                alertNotificationsGroupsMap[target.id] = [];
              }
              alertNotificationsGroupsMap[target.id].push(group.id);
            });
          }
 
          groupsMap[group.id] = group;
          var previousGroup = App.cache['previousAlertGroupsFullMap'][group.id] ? App.cache['previousAlertGroupsFullMap'][group.id] : {};
          var changedFields = self.getDiscrepancies(group, previousGroup, ['name', 'description', 'default', 'targets', 'definitions']);
          if (Object.keys(changedFields).length) {
            alertGroups.push(group);
          }
        }, this);
 
        Eif (!ignoreDelete) {
          groupsToDelete.forEach(function (groupId) {
            self.deleteRecord(App.AlertGroup.find(groupId));
          });
        }
 
        App.cache['previousAlertGroupsMap'] = alertDefinitionsGroupsMap;
        App.cache['previousAlertGroupsFullMap'] = groupsMap;
        App.cache['alertNotificationsGroupsMap'] = alertNotificationsGroupsMap;
        // initial load takes much more time than others, but it's OK (all data should be saved first time)
        App.store.safeLoadMany(this.get('model'), alertGroups);
        console.timeEnd('App.alertGroupsMapper execution time');
      }
    }
  });
});