public CubeItemControl(CubeDefInfo info, bool useIcon)
            : base(useIcon)
        {
            if (info == null)
                throw new ArgumentNullException("info");
            
            m_Info = info;
            Text = info.Caption;

            if (useIcon)
            {
                Icon = UriResources.Images.Cube16;
            }
        }
        public static CubeDefInfo CreateCubeInfo(CubeDef cube)
        {
            if (cube == null)
                return null;
            CubeDefInfo info = new CubeDefInfo();
            info.Caption = cube.Caption;
            info.Description = cube.Description;
            info.Name = cube.Name;
            info.LastProcessed = cube.LastProcessed;
            info.LastUpdated = cube.LastUpdated;
            info.Type = (CubeInfoType)(cube.Type);

            // Свойства
            foreach (Property prop in cube.Properties)
            {
                //PropertyInfo pi = new PropertyInfo(prop.Name, prop.Type, prop.Value);
                PropertyInfo pi = new PropertyInfo(prop.Name, prop.Value);
                info.Properties.Add(pi);
            }
            return info;
        }
Beispiel #3
0
        public static CubeDefInfo CreateCubeInfo(CubeDef cube)
        {
            if (cube == null)
            {
                return(null);
            }
            CubeDefInfo info = new CubeDefInfo();

            info.Caption       = cube.Caption;
            info.Description   = cube.Description;
            info.Name          = cube.Name;
            info.LastProcessed = cube.LastProcessed;
            info.LastUpdated   = cube.LastUpdated;
            info.Type          = (CubeInfoType)(cube.Type);

            // Свойства
            foreach (Property prop in cube.Properties)
            {
                //PropertyInfo pi = new PropertyInfo(prop.Name, prop.Type, prop.Value);
                PropertyInfo pi = new PropertyInfo(prop.Name, prop.Value);
                info.Properties.Add(pi);
            }
            return(info);
        }
 public void InitializeMetadata(CubeDefInfo cubeInfo)
 {
     comboNonEmptyBehavior.ItemsSource = null;
     m_NonEmptyBehavoirSource.Clear();
     if (cubeInfo != null)
     {
         foreach (var info in cubeInfo.Measures)
         {
             // Не выводим вычисляемые меры
             if (String.IsNullOrEmpty(info.Expression))
             {
                 m_NonEmptyBehavoirSource.Add(new ComboBoxItemData() { Text = info.Name });
             }
         }
     }
     comboNonEmptyBehavior.ItemsSource = m_NonEmptyBehavoirSource;
 }
        public void Initialize(Dictionary<String, CalculationInfoBase> members, Dictionary<String, CalculationInfoBase> sets, CubeDefInfo cubeInfo, String measureGroupName)
        {
            m_Members = members;
            m_Sets = sets;
            m_ClearButton.IsEnabled = (Members.Count + Sets.Count) > 0;

            MemberCtrl.InitializeMetadata(cubeInfo);

            if(CubeBrowser.CubeInfo != cubeInfo)
                CubeBrowser.Initialize(cubeInfo);
            CubeBrowser.MeasureGroupName = measureGroupName;

            MemberCtrl.IsEnabled = SetCtrl.IsEnabled = false;

            foreach (CalculationInfoBase info in Members.Values)
            {
                CalcMemberInfo member = info as CalcMemberInfo;
                if (member != null)
                {
                    // Добавляем в список стандартных пользовательские строки форматирования
                    if (!String.IsNullOrEmpty(member.FormatString))
                    {
                        if (!FormatStrings.Contains(member.FormatString))
                            FormatStrings.Add(member.FormatString);
                    }
                }
            }

            MemberCtrl.FormatStrings = FormatStrings;
            MembersList.Initialize(members, sets);

            RefreshMetadataTree();

            //CalcMemberInfo memberInfo = MembersList.CurrentObject as CalcMemberInfo;
            //if (memberInfo != null)
            //{
            //    MemberCtrl.Initialize(memberInfo);
            //}
        }
 protected void CreateKPIs(CustomTreeNode parentNode, CubeDefInfo cube, bool kpiParameters)
 {
     if (cube != null)
     {
         this.IsBusy = true;
         m_KpiStorage = new Dictionary<string, KpiView>();
         this.m_SourceKpis = cube.Kpis;
         this.KpiDataContainer.Grid.Columns.Clear();
         this.RowIndex = this.ExecuteQueryForRow(0);
         this.KpisLoadCompleted += new EventHandler(KpiViewer_KpisLoadCompleted);
     }
 }
        public void Initialize(CubeDefInfo cubeInfo)
        {
            Groups.Clear();
            Groups.Add(RootGroup.Name, RootGroup); 

            if (cubeInfo != null)
            {
                // Создаем описатели групп мер
                foreach (MeasureGroupInfo groupInfo in cubeInfo.MeasureGroups)
                {
                    if (!Groups.ContainsKey(groupInfo.Name))
                    {
                        Groups.Add(groupInfo.Name, new GroupInfo(groupInfo.Name, groupInfo.Caption));
                    }
                }

                foreach (MeasureInfo measureInfo in cubeInfo.Measures)
                {
                    String groupName = measureInfo.MeasureGroup;

                    // Если папка указана, то добавлем в иерархию (если она не привязана к группе, то она попадает в корневую коллекцию папкок)
                    // DisplayFolder может содержать иерархию папок, разделенную "\\"
                    if (!String.IsNullOrEmpty(measureInfo.DisplayFolder))
                    {
                        // Определяем группу, в которую входит данная папка (группы может и не быть)
                        GroupInfo groupInfo = null;
                        if (!String.IsNullOrEmpty(groupName) && Groups.ContainsKey(groupName))
                        {
                            groupInfo = Groups[groupName];
                        }

                        // Разбиваем полный путь на составляющие и создаем папку для каждой из них
                        String[] folders_names = measureInfo.DisplayFolder.Split(new String[] { "\\" }, StringSplitOptions.RemoveEmptyEntries);
                        if (folders_names != null)
                        {
                            String folderName = String.Empty;
                            FolderInfo prev_folderInfo = null;
                            foreach (String folderCaption in folders_names)
                            {
                                // Создаем узел для группы
                                if (!String.IsNullOrEmpty(folderCaption))
                                {
                                    // Получаем имя папки для данного уровня
                                    if (!String.IsNullOrEmpty(folderName))
                                    {
                                        folderName += "\\";
                                    }
                                    folderName += folderCaption;

                                    // Пытаемся найти папку с данным именем. Если она не найдена, то создаем ее
                                    FolderInfo folderInfo = GetFolder(groupInfo != null ? groupInfo.Name : String.Empty, folderName);
                                    if (folderInfo == null)
                                    {
                                        // Создаем данную папку
                                        folderInfo = new FolderInfo(folderName, folderCaption);

                                        // Если предыдущая папка в иерархии известна, то добавляем в нее
                                        if (prev_folderInfo != null)
                                        {
                                            prev_folderInfo.Folders.Add(folderName, folderInfo);
                                        }
                                        else
                                        {
                                            // Если группа известна то добавляем в группу в коллекцию корневых, иначе просто в коллекцию корневых папок
                                            if (groupInfo != null)
                                                groupInfo.Folders.Add(folderName, folderInfo);
                                            else
                                                RootGroup.Folders.Add(folderName, folderInfo);
                                        }
                                    }

                                    prev_folderInfo = folderInfo;
                                }
                            }
                        }
                    }
                }
            }
        }
		void ResetSettings()
		{
			m_CSDescr = null;
			m_CubeMetaData = null;
			m_CellSetProvider = null;
			UpdateToolbarButtons(null);
			UpdateEditToolBarButtons();
		}
		void OlapDataLoader_DataLoaded(object sender, DataLoaderEventArgs e)
		{
			bool stopWaiting = true;

			try
			{
				// Exception
				if (e.Error != null)
				{
					LogManager.LogError(this, e.Error.ToString());
					return;
				}

				// Exception or Message from Olap-Service
				if (e.Result.ContentType == InvokeContentType.Error)
				{
					LogManager.LogError(this, e.Result.Content);
					return;
				}

				PivotGrid.Focus();

				if (e.UserState != null && e.UserState.ToString() == "ValueCopyDialog_OkButton")
				//ValueCopyControl copy = e.UserState as ValueCopyControl;
				//if (copy != null)
				{
					stopWaiting = false;
					RunServiceCommand(ServiceCommandType.Refresh);
					return;
				}


				ValueDeliveryControl dilivery = e.UserState as ValueDeliveryControl;
				if (dilivery != null)
				{
					if (!string.IsNullOrEmpty(e.Result.Content))
					{
						CellSetData cs_descr = CellSetData.Deserialize(e.Result.Content);
						dilivery.InitializeMembersList(new CellSetDataProvider(cs_descr));
					}
					return;
				}

				PivotInitializeArgs args = e.UserState as PivotInitializeArgs;
				if (args != null)
				{
					if (!string.IsNullOrEmpty(e.Result.Content))
					{
						CellSetData cs_descr = CellSetData.Deserialize(e.Result.Content);
						Initialize(cs_descr);
					}
					else
					{
						Initialize(null);
					}
					return;
				}

				PerformMemberActionArgs action_args = e.UserState as PerformMemberActionArgs;
				if (action_args != null)
				{
					MemberActionCompleted(e);
					return;
				}

				if (e.UserState != null && e.UserState is ServiceCommandType)
				{
					ServiceCommandType actionType = (ServiceCommandType)(ServiceCommandType.Parse(typeof(ServiceCommandType), e.UserState.ToString(), true));
					// Save to File
					if (actionType == ServiceCommandType.ExportToExcel)
					{
						if (ExportToExcelFile)
						{
							SaveToFile(e.Result.Content);
							return;
						}
					}
					else
					{
						if (!string.IsNullOrEmpty(e.Result.Content))
						{
							CellSetData cs_descr = CellSetData.Deserialize(e.Result.Content);
							Initialize(cs_descr);
						}
					}

					UpdateButtons();
					ServiceCommandCompleted(actionType);
					return;
				}

				//PivotGridToolBarInfo toolbar_args = e.UserState as PivotGridToolBarInfo;
				//if (toolbar_args != null)
				//{
				//    if (!string.IsNullOrEmpty(e.Result.Content))
				//    {
				//        toolbar_args = XmlSerializationUtility.XmlStr2Obj<PivotGridToolBarInfo>(e.Result.Content);
				//        UpdateToolbarButtons(toolbar_args);
				//    }
				//    //this.Focus();
				//    return;
				//}

				//UpdateCubeArgs update_Args = e.UserState as UpdateCubeArgs;
				//if (update_Args != null)
				List<UpdateEntry> entries = e.UserState as List<UpdateEntry>;
				if (entries != null)
				{
					// Результат - коллекция строк. Если на какой-то ячейке произошла ошибка, то в соотв. строке будет ее текст
					List<String> results = XmlSerializationUtility.XmlStr2Obj<List<String>>(e.Result.Content);
					if (results != null && results.Count == entries.Count)
					{
						StringBuilder sb = new StringBuilder();
						var successful = new List<UpdateEntry>();
						for (int i = 0; i < results.Count; i++)
						{
							if (String.IsNullOrEmpty(results[i]))
							{
								// No error
								entries[i].Error = String.Empty;
								// Update is successful. 
								successful.Add(entries[i]);
								// Update is successful. Remove this change from local cache
								PivotGrid.LocalChanges.RemoveChange(entries[i]);
							}
							else
							{
								// Error message
								entries[i].Error = results[i];
								sb.AppendLine(results[i]);
								PivotGrid.LocalChanges.Add(entries[i]);
							}
						}
						// Add cell changes to Transaction cache
						if (successful.Count > 0)
						{
							OlapTransactionManager.AddPendingChanges(Connection, successful);
						}

						if (!String.IsNullOrEmpty(sb.ToString()))
						{
							LogManager.LogError(this, sb.ToString());
						}
					}

					UpdateEditToolBarButtons();
					UpdateCubeCompleted();
					//this.Focus();
					return;
				}

				ValueCopyControl copyControl = e.UserState as ValueCopyControl;
				if (copyControl != null)
				{
					CubeDefInfo cs_descr = XmlSerializationUtility.XmlStr2Obj<CubeDefInfo>(e.Result.Content);
					m_CubeMetaData = cs_descr;
					copyControl.IsBusy = false;
					copyControl.InitializeMetadata(cs_descr);
				}

				MemberInfoWrapper<MetadataQuery> metadata_args = e.UserState as MemberInfoWrapper<MetadataQuery>;
				if (metadata_args != null)
				{
					switch (metadata_args.UserData.QueryType)
					{
						case MetadataQueryType.GetLevelProperties:
							List<LevelPropertyInfo> properties = XmlSerializationUtility.XmlStr2Obj<List<LevelPropertyInfo>>(e.Result.Content);
							m_LevelProperties[metadata_args.Member.HierarchyUniqueName] = properties;
							LoadMemberAttributes(metadata_args.Member, properties);
							break;
					}
				}

				UserSchemaWrapper<String, CellInfo> user_wrapper = e.UserState as UserSchemaWrapper<String, CellInfo>;
				if (user_wrapper != null && user_wrapper.Schema == "DRILLTHROUGH_CELL")
				{
					if (!String.IsNullOrEmpty(e.Result.Content))
					{
						DataTableWrapper tableWrapper = XmlSerializationUtility.XmlStr2Obj<DataTableWrapper>(e.Result.Content);
						ShowDrillthroughResult(user_wrapper.UserData, tableWrapper);
					}
				}

				SortPropertiesControl sortControl = e.UserState as SortPropertiesControl;
				if (sortControl != null)
				{
					List<MeasureInfo> list = XmlSerializationUtility.XmlStr2Obj<List<MeasureInfo>>(e.Result.Content);
					sortControl.InitializeMeasuresList(list);
				}

				//MemberInfoWrapper<MemberChoiceQuery> member_args = e.UserState as MemberInfoWrapper<MemberChoiceQuery>;
				//if (member_args != null)
				if (e.UserState != null && e.UserState.ToString() == "CUSTOM_MEMBER_PROPERTIES")
				{
					//switch (member_args.UserData.QueryType)
					{
						//case MemberChoiceQueryType.GetMember:

						MemberData member = null;
						if (!String.IsNullOrEmpty(e.Result.Content))
						{
							CellSetData cellSet = CellSetData.Deserialize(e.Result.Content);
							if (cellSet != null && cellSet.Axes.Count > 0 && cellSet.Axes[0].Members.Count > 0)
								member = cellSet.Axes[0].Members[0];
						}

						if (member != null)
						{
							ShowMemberAttributes(member);
						}
						else
						{
							MessageBox.Show(Localization.PivotGrid_CustomProperties_NotFound, Localization.Warning, MessageBoxButton.OK);
						}
						//break;
					}
				}
			}
			finally
			{
				if (stopWaiting)
					IsWaiting = false;
			}
		}
 public void Initialize(CubeDefInfo cubeInfo, Value_FilterWrapper wrapper)
 {
     comboMeasure.Initialize(cubeInfo);
     Initialize(wrapper);
 }
 public void Initialize(CubeDefInfo cubeInfo)
 {
     comboMeasure.Initialize(cubeInfo);
 }
 public void Initialize(CubeDefInfo cubeInfo)
 {
     m_CubeInfo = cubeInfo;
     CreateMeasures();
 }
 public CubeTreeNode(CubeDefInfo info) : base(info)
 {
     Icon = UriResources.Images.Cube16;
 }
 public void Initialize(CubeDefInfo cubeInfo)
 {
     m_CubeInfo = cubeInfo;
     m_TopFilterControl.Initialize(cubeInfo);
     m_ValueFilterControl.Initialize(cubeInfo);
 }
        public void InitializeMetadata(CubeDefInfo cubeInfo)
        {
            List<CoordinateItem> list = new List<CoordinateItem>();
            
            if(cubeInfo != null)
            {
                foreach (DimensionInfo dim_Info in cubeInfo.Dimensions)
                {
                    foreach (HierarchyInfo hier_info in dim_Info.Hierarchies)
                    {
                        CoordinateItem item = new CoordinateItem(dim_Info.UniqueName, hier_info.UniqueName);
                        item.Hierarchy_Custom_AllMemberUniqueName = hier_info.Custom_AllMemberUniqueName;
                        item.DimensionCaption = dim_Info.Caption;
                        item.HierarchyCaption = hier_info.Caption;
                        if (m_Slice != null && m_Slice.ContainsKey(hier_info.UniqueName))
                        {
                            MemberWrap wrap = m_Slice[hier_info.UniqueName];
                            item.SourceMember = wrap;

                            item.DestMember = wrap;
                            // Если в приемник попадает элемент типа ALL, то
                            // пытаемся заменить его на DefaultMember. Если же DefaultMember совпадет в итоге с AllMember
                            // то в приемник устанавливаем Unknown элемент
                            if (!String.IsNullOrEmpty(hier_info.Custom_AllMemberUniqueName) &&
                                hier_info.Custom_AllMemberUniqueName == wrap.UniqueName)
                            {
                                if (!String.IsNullOrEmpty(hier_info.DefaultMember) &&
                                    hier_info.DefaultMember == hier_info.Custom_AllMemberUniqueName)
                                {
                                    MemberWrap unk_wrap = new MemberWrap();
                                    unk_wrap.IsUnknownMember = true;
                                    item.DestMember = unk_wrap;
                                }
                                else
                                {
                                    if (!String.IsNullOrEmpty(hier_info.DefaultMember))
                                    {
                                        MemberWrap def_wrap = new MemberWrap();
                                        def_wrap.IsDefaultMember = true;
                                        item.DestMember = def_wrap;
                                    }
                                }
                            }
                        }
                        list.Add(item);
                    }
                }
            }
            m_Coordinates.Initialize(list);
        }
        private void ApplyItemsSelection()
        {
            CubeTreeNode node = null;
            node = Tree.SelectedItem as CubeTreeNode;

            //Запоминаем выбранный элемент
            m_SelectedInfo = node != null ? node.Info as CubeDefInfo : null;
        }