repeatPanel(panel, row) {
    var variable = _.find(this.variables, {name: panel.repeat});
    if (!variable) { return; }

    var selected;
    if (variable.current.text === 'All') {
      selected = variable.options.slice(1, variable.options.length);
    } else {
      selected = _.filter(variable.options, {selected: true});
    }

    _.each(selected, (option, index) => {
      var copy = this.getPanelClone(panel, row, index);
      copy.span = Math.max(12 / selected.length, panel.minSpan || 4);
      copy.scopedVars = copy.scopedVars || {};
      copy.scopedVars[variable.name] = option;
    });
  }

 private _populateFunctions(): void {
     const functionsAbi = _.filter(this.abi, abiPart => abiPart.type === AbiType.Function) as FunctionAbi[];
     _.forEach(functionsAbi, (functionAbi: MethodAbi) => {
         if (functionAbi.constant) {
             const cbStyleCallFunction = this._contract[functionAbi.name].call;
             this[functionAbi.name] = promisify(cbStyleCallFunction, this._contract);
             this[functionAbi.name].call = promisify(cbStyleCallFunction, this._contract);
         } else {
             const cbStyleFunction = this._contract[functionAbi.name];
             const cbStyleCallFunction = this._contract[functionAbi.name].call;
             const cbStyleEstimateGasFunction = this._contract[functionAbi.name].estimateGas;
             this[functionAbi.name] = this._promisifyWithDefaultParams(cbStyleFunction);
             this[functionAbi.name].estimateGasAsync = promisify(cbStyleEstimateGasFunction);
             this[functionAbi.name].sendTransactionAsync = this._promisifyWithDefaultParams(cbStyleFunction);
             this[functionAbi.name].call = promisify(cbStyleCallFunction, this._contract);
         }
     });
 }

export function getCapAlignment(polyhedron: Polyhedron, cap: Cap) {
  const isRhombicosidodecahedron = cap.type === 'cupola';
  const orthoCaps = isRhombicosidodecahedron
    ? _.filter(
        Cap.getAll(polyhedron),
        cap => getCupolaGyrate(polyhedron, cap) === 'ortho',
      )
    : [];

  const otherNormal =
    orthoCaps.length > 0
      ? getSingle(orthoCaps)
          .boundary()
          .normal()
      : polyhedron.largestFace().normal();

  return isInverse(cap.normal(), otherNormal) ? 'para' : 'meta';
}

        it('should be able to set all recipe ingredients', () => {

            let recipe = RecipeMock.entity();

            let leftoverIngredient = MealLeftoverIngredient.convertToMealLeftoverIngredient(_.head(recipe._ingredients));

            let meal = new Meal({
                _recipes: [recipe],
                _leftoverIngredients: [leftoverIngredient]
            });

            expect(
                _.filter(meal.__allRecipeIngredients, (recipeIngredient:ISelectedRecipeIngredient) => {
                    return recipeIngredient.selected;
                }).length
            ).to.equal(1);

        });

export default function getOverlappingStudies(studies: CancerStudy[]):CancerStudy[][] {
    const groupedTCGAStudies = _.reduce(studies,(memo, study:CancerStudy)=>{
        if (/_tcga/.test(study.studyId)) {
            // we need to find when root of study name is in duplicate, so strip out the modifiers (pub or pancan)
            const initial = study.studyId.replace(/(_\d\d\d\d|_pub|(_pub\d\d\d\d)|_pan_can_atlas_\d\d\d\d)$/g,'');
            if (initial) {
                if (initial in memo) {
                    memo[initial].push(study);
                } else {
                    memo[initial] = [study];
                }
            }
        }

        return memo;
    }, {} as { [studyId:string]:CancerStudy[] });
    return _.filter(groupedTCGAStudies, (grouping)=>grouping.length > 1);
}

 private populateFunctions(): void {
     const functionsAbi = _.filter(this.abi, abiPart => abiPart.type === AbiType.Function);
     _.forEach(functionsAbi, (functionAbi: Web3.MethodAbi) => {
         if (functionAbi.constant) {
             const cbStyleCallFunction = this.contract[functionAbi.name].call;
             this[functionAbi.name] = {
                 callAsync: promisify(cbStyleCallFunction, this.contract),
             };
         } else {
             const cbStyleFunction = this.contract[functionAbi.name];
             const cbStyleEstimateGasFunction = this.contract[functionAbi.name].estimateGas;
             this[functionAbi.name] = {
                 estimateGasAsync: promisify(cbStyleEstimateGasFunction, this.contract),
                 sendTransactionAsync: this.promisifyWithDefaultParams(cbStyleFunction),
             };
         }
     });
 }

function getExecutionDefinitionsAndColumns(mdObj: any, options: any, attributesMap: any) {
    const measures = getMeasures(mdObj);
    let attributes = getAttributes(mdObj);

    const metrics = flatten(map(measures, (measure, index) =>
        getMetricFactory(measure, mdObj)(measure, mdObj, index, attributesMap))
    );
    if (options.removeDateItems) {
        attributes = filter(attributes, attribute => !isDateAttribute(attribute, attributesMap));
    }
    attributes = map(attributes, partial(categoryToElement, attributesMap, mdObj));

    const columns = compact(map([...attributes, ...metrics], 'element'));
    return {
        columns,
        definitions: sortDefinitions(compact(map(metrics, 'definition')))
    };
}

        ]).spread((uiDescriptor) => {
            let vm = parentContext.object._vm;
            context.object = _.map(_.reject(
                    _.filter(parentContext.object.devices, {type: this.vmRepository.DEVICE_TYPE.VOLUME}),
                    {properties: {type: 'NFS'}}
                ),
                volume => _.assign(volume, {
                    _objectType: objectType,
                    _vm: vm,
                    id: uuid.v4()
                })
            );
            context.object._vm = parentContext.object;
            context.object._objectType = objectType;
            context.userInterfaceDescriptor = uiDescriptor;

            return this.updateStackWithContext(this.stack, context);
        });

 formatter: function () {
   //TODO: check this
   //let s = '<b>' + Highcharts.dateFormat('%A, %b %d, %H:%M', new Date(this.x)) + '</b>';
   let dateFormat = newOptions.dateFormat || '%A, %b %d, %H:%M';
   let s = '<b>' + Highcharts.dateFormat(dateFormat, this.x) + '</b>';
   if (_.filter(this.points, (point: any) => {
       return point.y !== 0;
     }).length) {
     _.forEach(this.points, function (point) {
       if (point.y) {
         let name = ' ' + (point.series.options.labelPrefix ? point.series.options.labelPrefix + ' ' + point.series.name : point.series.name);
         s += '<br /><span style="color:' + point.color + '">\u25CF</span>' + name + ': <b>' + (point.series.options.decimalFormat?Highcharts.numberFormat(point.y, 2):point.y) +
           (point.series.options.labelSuffix?point.series.options.labelSuffix:'') + '</b>';
       }
     });
   }
   return s;
 },

  // remove stuff that should not count in diff
  cleanDashboardFromIgnoredChanges(dashData) {
    // need to new up the domain model class to get access to expand / collapse row logic
    let model = new DashboardModel(dashData);

    // Expand all rows before making comparison. This is required because row expand / collapse
    // change order of panel array and panel positions.
    model.expandRows();

    let dash = model.getSaveModelClone();

    // ignore time and refresh
    dash.time = 0;
    dash.refresh = 0;
    dash.schemaVersion = 0;

    // ignore iteration property
    delete dash.iteration;

    dash.panels = _.filter(dash.panels, panel => {
      if (panel.repeatPanelId) {
        return false;
      }

      // remove scopedVars
      panel.scopedVars = null;

      // ignore panel legend sort
      if (panel.legend) {
        delete panel.legend.sort;
        delete panel.legend.sortDesc;
      }

      return true;
    });

    // ignore template variable values
    _.each(dash.templating.list, function(value) {
      value.current = null;
      value.options = null;
      value.filters = null;
    });

    return dash;
  }