public void AddDimensionLevelTest()
 {
     Dimension target = new Dimension();
     Dimension d = new Dimension();
     target.AddDimensionLevel(d);
     Assert.AreEqual(d, target.GetCoarserDimensionLevel()[0]);
 }
 public void AddDimensionLevelTest1()
 {
     Dimension target = new Dimension();
     List<Dimension> l = new List<Dimension>() { new Dimension() };
     target.AddDimensionLevel(l);
     Assert.AreEqual(l[0], target.GetCoarserDimensionLevel()[0]);
 }
 public SelectedDimension(int axis = 0, Dimension dimension = null, int levelDepth = 0, int aggregationDepth = 0, bool areFiltersSelected = false, List<DimensionContent> selectedFilters = null, bool isAllLevel = false)
 {
     IsAllLevelSelected = isAllLevel;
     Axis = axis;
     Dimension = dimension ?? new Dimension();
     LevelDepth = levelDepth;
     AggregationDepth = aggregationDepth;
     AreFiltersSelected = areFiltersSelected;
     SelectedFilters = selectedFilters ?? new List<DimensionContent>();
 }
 /// <summary>
 /// Creates a Join-statement for a given dimension.
 /// </summary>
 /// <param name="dimension"></param>
 /// <returns></returns>
 /// <author>Jannik Arndt, Bernhard Bruns, Bernd Nottbeck</author>
 public virtual string CreateJoinStatementFromDimension(Dimension dimension)
 {
     StringBuilder joinStatement = new StringBuilder();
     joinStatement.Append("JOIN ")
         .Append(TableNameFormatter(dimension.ToTable))
         .Append(" ON ")
         .Append(TableColumnFormatter(dimension.FromTable, dimension.FromColumn))
         .Append(" = ")
         .Append(TableColumnFormatter(dimension.ToTable, dimension.ToColumn))
         .Append(" ");
     return joinStatement.ToString();
 }
        public void CompareDimensionTest()
        {
            Dimension d1 = new Dimension();
            Dimension d2 = new Dimension();

            d1.DimensionLevelsList = new List<Dimension> {new Dimension()};

            d2.DimensionLevelsList = new List<Dimension>();

            PrivateType pt = new PrivateType(typeof(XMLHelper));
            bool result = (bool)pt.InvokeStatic("CompareDimensions", new Object[] { d1, d2 });

            Assert.IsFalse(result);
        }
        /// <summary>
        /// Recursively go through all level steps and return a list of all necessary join-statements.
        /// </summary> 
        /// <param name="list">The list that needs to be filled</param> 
        /// <param name="dimension"></param>
        /// <param name="grain"></param> 
        /// <returns></returns> 
        /// <author>Jannik Arndt, Bernd Nottbeck</author>
        public virtual List<string> CollectAllJoinStatements(List<string> list, Dimension dimension, int grain)
        {
            if (grain < 0)
            {
                return list;
            }

            if (grain > 0 && dimension != null && dimension.GetCoarserDimensionLevel() != null)
                CollectAllJoinStatements(list, dimension.GetCoarserDimensionLevel()[0], --grain);

            if (dimension != null && dimension.ToTable != "")
                list.Add(CreateJoinStatementFromDimension(dimension));

            return list;
        }
        /// <summary>
        /// Method to Add the logical dimension ALL to every dimension "axis"
        /// </summary>
        /// <param name="dimensionList">dimension "axis" list</param>
        public void AddAllLevel(List<Dimension> dimensionList)
        {
            foreach (var dimension in dimensionList)
            {
                if (dimension.IsEmptyDimension)
                    continue;

                var temp = dimension;
                while (temp.DimensionLevelsList.Count != 0)
                    temp = temp.DimensionLevelsList[0];

                var allDimension = new Dimension("ALL", "MPMALLAGGREGATION", "", "", "MPMALLAGGREGATION", "ALL");

                allDimension.DimensionContentsList.Add(new DimensionContent("0", "ALL", "ALL"));
                temp.AddDimensionLevel(allDimension);
            }
        }
 /// <summary>
 /// Adds a single Dimension (usually for coarser level).
 /// </summary>
 /// <param Name="dimension">A Dimension-Object</param>
 /// <author>Jannik Arndt</author>
 public void AddDimensionLevel(Dimension dimension)
 {
     DimensionLevelsList.Add(dimension);
 }
        private bool allLevelSelected(Dimension dimension, int levelDepth)
        {
            if (levelDepth > 1)
            {
                return allLevelSelected(dimension.DimensionLevelsList[0], levelDepth - 1);
            }

            return dimension.FromConstraint == "MPMALLAGGREGATION";
        }
 public void to_tableTest()
 {
     Dimension target = new Dimension();
     string expected = "Teststring";
     string actual;
     target.ToTable = expected;
     actual = target.ToTable;
     Assert.AreEqual(expected, actual);
 }
 public void to_constraintTest()
 {
     Dimension target = new Dimension();
     string expected = "Teststring";
     string actual;
     target.ToConstraint = expected;
     actual = target.ToConstraint;
     Assert.AreEqual(expected, actual);
 }
        public void GetLevelTest()
        {
            Dimension target = new Dimension();
            Dimension d1 = new Dimension();
            Dimension d2 = new Dimension();
            d1.AddDimensionLevel(d2);
            target.AddDimensionLevel(d1);

            List<Dimension> actual = target.GetLevel();
            Assert.AreEqual(actual.Count, 3);
        }
 /// <summary>
 /// Go through all Axis-Selector-ComboBoxes except the given one and check, if the dimension is already displayed somewhere
 /// </summary>
 /// <param name="dimension">The dimension that this method looks for</param>
 /// <param name="except">If this ComboBox displays the dimension, it is being ignored</param>
 /// <returns></returns>
 /// <author>Jannik Arndt</author>
 public ComboBox CheckIfDimensionIsAlreadySelected(Dimension dimension, ComboBox except)
 {
     return _listOfAxisComboBoxes.FirstOrDefault(comboBox => comboBox.SelectedItem == dimension && !comboBox.Equals(except));
 }
        /// <summary>
        /// Update internal event selection model.
        /// </summary>
        /// <param Name="axis"></param>
        /// /// <param Name="dim"></param>
        /// /// <param Name="levelDepth"></param>
        /// /// <param Name="dimContent"></param>
        /// <param name="aggregationDepth"></param>
        public void Update(int axis, Dimension dim, int levelDepth, int aggregationDepth, List<DimensionContent> dimContent)
        {
            SelectedDimension showEmptyDimension = null;

            foreach (SelectedDimension selectedDimension in _instance.SelectedDimensions)
            {
                if (selectedDimension.Axis == axis)
                {
                    if (dim.IsEmptyDimension)
                    {
                        showEmptyDimension = selectedDimension;
                    }
                    else
                    {
                        selectedDimension.Dimension = dim;
                        selectedDimension.LevelDepth = levelDepth;
                        selectedDimension.AggregationDepth = aggregationDepth - 1; //-1 exclude the logical no aggregation dimension
                        selectedDimension.SelectedFilters = dimContent;

                        if (allLevelSelected(selectedDimension.Dimension, selectedDimension.LevelDepth))
                        {
                            selectedDimension.IsAllLevelSelected = true;
                        } else {
                            selectedDimension.IsAllLevelSelected = false;
                        }
                    }
                    break;
                }
            }

            if (showEmptyDimension != null)
            {
                _instance.SelectedDimensions.Remove(showEmptyDimension);
            }
            _instance.SelectionHasChangedSinceLastLoading = true;
        }
 /// <summary>
 /// Looks if the given dimension is also selected by another selector as the given one.
 /// <param name="showingDimensionSelector">Selector which currently show the dimension.</param>
 /// <param name="dimension">Dimension to look for.</param>
 /// </summary>
 private bool IsAlreadySelected(EventDimensionSelector showingDimensionSelector, Dimension dimension)
 {
     foreach (EventDimensionSelector dimSelector in _listOfDimensionSelectors)
     {
         if (dimSelector.DimensionComboBox.SelectedItem == dimension && dimSelector != showingDimensionSelector)
         {
             return true;
         }
     }
     return false;
 }
 public void from_columnTest()
 {
     Dimension target = new Dimension();
     string expected = "Teststring";
     string actual;
     target.FromColumn = expected;
     actual = target.FromColumn;
     Assert.AreEqual(expected, actual);
 }
 public void DimensionConstructorTest()
 {
     Dimension target = new Dimension();
     Assert.IsNotNull(target);
 }
        /// <summary>
        /// This takes a tablename (most likely "FACT") and loads all foreign keys, which should point to a dimension (Table + column).
        /// It creates a List of Dimensions and adds a dimension for each row the Database returns. It then goes on recursively 
        /// and grabs the Table + Column of the "next" Table, meaning the one you end up at, if you roll up the cube.
        /// Note that in this piece of code a dimension may have MULTIPLE sub-ListOfDimensions, which should not exist in the model, 
        /// but IF they do, it's not a problem at this point (but rather a GUI-problem)
        /// </summary>
        /// <param name="tablename">The Name of the Table whose ListOfDimensions are to be found.</param>
        /// <returns>A list of ListOfDimensions which, most likely, contain even more ListOfDimensions themselves.</returns>
        /// <author>Jannik Arndt, Bernd Nottbeck</author>
        public List<Dimension> GetDimensionsOf(String tablename)
        {
            DataTable referencedTables;
            DataTable dimensionContentDataTable;
            List<Dimension> resultingListOfDimensions = new List<Dimension>();

            try
            {
                Open();

                // every table row is a dimension
                referencedTables = GetReferencingDataTable(tablename);

                foreach (DataRow referencedTableRow in referencedTables.Rows)
                {
                    // create a dimension-object (see MetaWorker.Dimension)
                    Dimension newDimension = new Dimension(referencedTableRow["FromColumn"].ToString(), referencedTableRow["FromConstraint"].ToString(),
                        referencedTableRow["FromTable"].ToString(), referencedTableRow["FromColumn"].ToString(),
                        referencedTableRow["ToConstraint"].ToString(), referencedTableRow["ToTable"].ToString(), referencedTableRow["ToColumn"].ToString());

                    // Load the content of this table
                    dimensionContentDataTable = GetTableContent(referencedTableRow["ToTable"].ToString());

                    // create DimensionContent-Objects and add them to the current dimension
                    foreach (DataRow dimensionContentRow in dimensionContentDataTable.Rows)
                    {
                        string description = "";
                        if (dimensionContentRow.ItemArray.Count() > 2)
                            description = dimensionContentRow[2].ToString();
                        newDimension.DimensionContentsList.Add(new DimensionContent(dimensionContentRow[0].ToString(), dimensionContentRow[1].ToString(), description));
                    }

                    // save the DimensionColumnNames for generated DB-querys
                    newDimension.DimensionColumnNames = new DimensionColumnNames(dimensionContentDataTable.Columns[0].ColumnName,
                        dimensionContentDataTable.Columns[1].ColumnName, dimensionContentDataTable.Columns[2].ColumnName);

                    dimensionContentDataTable.Reset();
                    // now recursively find all sub-ListOfDimensions of this Table and add them to the current dimension
                    newDimension.AddDimensionLevel(GetDimensionsOf(referencedTableRow["ToTable"].ToString()));

                    // add the current dimension to the list that will be returned eventually
                    resultingListOfDimensions.Add(newDimension);
                }
                return resultingListOfDimensions;
            }
            finally
            {
                Close();
            }
        }
        /// <summary>
        /// Returns the dimension table for the given level
        /// </summary>
        /// <param name="dimension"></param>
        /// /// <param name="levelDepth"></param>
        /// <author>Roman Bauer</author>
        private Dimension getDimensionByLevelDepth(Dimension dimension, int levelDepth)
        {
            if (levelDepth > 1)
                return getDimensionByLevelDepth(dimension.DimensionLevelsList[0], levelDepth - 1);

            return dimension;
        }
 public void DimensionConstructorTest1()
 {
     string setname = "Teststring";
     string setfrom_constraint = "Teststring";
     string setfrom_table = "Teststring";
     string setfrom_column = "Teststring";
     string setto_constraint = "Teststring";
     string setto_table = "Teststring";
     string setto_column = "Teststring";
     Dimension target = new Dimension(setname, setfrom_constraint, setfrom_table, setfrom_column, setto_constraint, setto_table, setto_column);
     Assert.IsNotNull(target);
 }
 /// <summary>
 /// Private method to build the list of sub-ListOfDimensions (=level) recursively.
 /// </summary>
 /// <param Name="dimension">Start with "this".</param>
 /// <author>Jannik Arndt</author>
 private void BuildLevelList(Dimension dimension)
 {
     LevelList.Add(dimension);
     if (dimension.DimensionLevelsList.Count > 0)
         BuildLevelList(dimension.DimensionLevelsList[0]);
 }
        private List<EventDimensionSelector> GetShowingDimensionSelectors(Dimension dimension)
        {
            List<EventDimensionSelector> foundSelectors = new List<EventDimensionSelector>();

            foreach (EventDimensionSelector dimSelector in _listOfDimensionSelectors)
            {
                if (dimSelector.DimensionComboBox.SelectedItem == dimension)
                {
                    foundSelectors.Add(dimSelector);
                }
            }
            return foundSelectors;
        }
        /// <summary>
        /// Init selector with the given dimensions.
        /// <param name="allDimensions">All dimensions which the selector could show.</param>
        /// <param name="dimensionToShow">Current dimension to show.</param>
        /// </summary>
        internal void Init(List<Dimension> allDimensions, Dimension dimensionToShow)
        {
            ShowedDimension = dimensionToShow;

            //set dimension
            List<Dimension> temp = new List<Dimension>();
            Dimension emptyDimension = new Dimension("no selection", toTable: "no selection", isEmptyDimension: true);

            temp.Add(emptyDimension);
            temp.AddRange(allDimensions);

            DimensionComboBox.ItemsSource = temp;
            DimensionComboBox.DisplayMemberPath = "Dimensionname";
            DimensionComboBox.SelectedItem = temp[temp.IndexOf(dimensionToShow)];

            //set level
            DimensionLevelComboBox.ItemsSource = dimensionToShow.GetLevel();
            DimensionLevelComboBox.DisplayMemberPath = "Level";
            DimensionLevelComboBox.SelectedIndex = DimensionLevelComboBox.Items.Count - 1;//select highest level by default

            //set aggregation
            temp = new List<Dimension>();
            Dimension emptyLevel = new Dimension("empty level", toTable: "no aggregation", isEmptyDimension: true);

            temp.Add(emptyLevel);
            temp.AddRange(dimensionToShow.GetLevel());

            DimensionAggregationComboBox.Items.Clear();

            //exclude the all level dimension for aggregation level combobox
            foreach (Dimension dim in temp)
            {
                if (dim != temp.Last())
                {
                    DimensionAggregationComboBox.Items.Add(dim);
                }
            }

            DimensionAggregationComboBox.DisplayMemberPath = "Level";
            DimensionAggregationComboBox.SelectedIndex = 0;

            //set content
            var showedLevel = (Dimension)DimensionLevelComboBox.SelectedItem;

            DimensionContentFilter.ItemsSource = showedLevel.DimensionContentsList;
            DimensionContentFilter.DisplayMemberPath = "content";
            DimensionContentFilter.SelectAll();

            DimensionContentSearch.Clear();
        }
 private void updateInternalEventSelectionModel(int axis, Dimension dimension, int levelDepth, int aggregatioDepth, List<DimensionContent> dimensionContent)
 {
     EventSelectionModel.GetInstance().Update(axis, dimension, levelDepth, aggregatioDepth, dimensionContent);
 }
        internal void UpdateByDimensionChange(Dimension newSelectedDimension)
        {
            ShowedDimension = newSelectedDimension;

            //update level
            DimensionLevelComboBox.ItemsSource = newSelectedDimension.GetLevel();

            //update aggregation level
            List<Dimension> temp = new List<Dimension>();
            Dimension emptyLevel = new Dimension("empty level", toTable: "no aggregation", isEmptyDimension: true);

            temp.Add(emptyLevel);
            temp.AddRange(newSelectedDimension.GetLevel());

            DimensionAggregationComboBox.Items.Clear();

            //exclude the all level for aggregation level combobox
            foreach (Dimension dim in temp)
            {
                if (dim != temp.Last())
                {
                    DimensionAggregationComboBox.Items.Add(dim);
                }
            }

            DimensionAggregationComboBox.DisplayMemberPath = "Level";
            DimensionAggregationComboBox.SelectedIndex = 0;

            //update content
            DimensionContentSearch.Clear();
        }