private bool ReadDataFromDB(byte[] selectedDashBoardBinary)
        {
            busyIndicator.IsBusy = true;
            bool retVal = true;

            try
            {
                lstOfFilters.Clear();
                lstOfNewFilters.Clear();
                var customReader = StreamingManagerReuse.Create(selectedDashBoardBinary);
                var version      = customReader.readByte();
                if (version < 1 || version > 3)
                {
                    return(false);
                }

                var bufferedReport = StreamingManager.readMemory(customReader);
                var st             = Compression.UncompressStream(bufferedReport);

                if (version < 3 && customReader.readBoolean())
                {
                    int filterCount = (int)customReader.readNum();
                    for (int i = 0; i < filterCount; i++)
                    {
                        var key        = customReader.readString();
                        var arrpropval = (PropValuePair[])customReader.ToArray(typeof(PropValuePair));
                        lstOfFilters.Add(key, arrpropval);
                    }
                }
                else if (version == 3)
                {
                    if (customReader.readBoolean())
                    {
                        int filterCount = (int)customReader.readNum();
                        for (int i = 0; i < filterCount; i++)
                        {
                            var key       = customReader.readString();
                            var arrFilter = (FilterProperties[])customReader.ToArray(typeof(FilterProperties));
                            lstOfNewFilters.Add(key, arrFilter.ToList());
                        }
                    }
                    if (customReader.readBoolean())
                    {
                        int filterCount = (int)customReader.readNum();
                        for (int i = 0; i < filterCount; i++)
                        {
                            var key = customReader.readString();
                            List <PropValuePair> propVal = new List <PropValuePair>();
                            var arrpropval = (PropValuePair[])customReader.ToArray(typeof(PropValuePair));
                            propVal = arrpropval.ToList();
                            lstOfFilters.Add(key, arrpropval);
                        }
                    }
                }
                if (customReader.readBoolean())
                {
                    int sortCount = (int)customReader.readNum();
                    for (int i = 0; i < sortCount; i++)
                    {
                        var          key      = customReader.readString();
                        var          arrSort  = (SortingProperties[])customReader.ToArray(typeof(SortingProperties));
                        FilterSorter propSort = new FilterSorter(arrSort);
                        if (lstOfSorters != null && !lstOfSorters.ContainsKey(key))
                        {
                            lstOfSorters.Add(key, propSort);
                        }
                    }
                }
                customReader.Release();

                XDocument xdoc    = XDocument.Load(st);
                var       element = xdoc.Root.Attributes().Where(x => x.Name == "RefreshTimer").FirstOrDefault();
                if (element != null)
                {
                    int refreshTimer = (int)NumberConvert.ToInt(element.Value);
                    if (refreshTimer > 0)
                    {
                        if (timer == null)
                        {
                            timer = new System.Windows.Forms.Timer();
                        }
                        timer.Interval = refreshTimer < 300 ? 300 * 1000 : refreshTimer * 1000;
                        timer.Tick    += Timer_Tick;
                        timer.Start();
                    }
                }
                ShowBusyIndicator();
                st.Seek(0, System.IO.SeekOrigin.Begin);
                dashboardViewerUniconta.LoadDashboard(st);
                st.Release();
                return(retVal);
            }
            catch (Exception ex)
            {
                ClearBusy();
                UnicontaMessageBox.Show(ex);
                CloseDockItem();
                return(false);
            }
        }
        private void DashboardViewerUniconta_DashboardLoaded(object sender, DevExpress.DashboardWpf.DashboardLoadedEventArgs e)
        {
            Dashboard dasdboard = e.Dashboard;

            foreach (var item in dasdboard?.Items)
            {
                var name = dasdboard?.CustomProperties.GetValue(item.ComponentName);
                if (name != null)
                {
                    if (name[0] == '&')
                    {
                        item.Name = Uniconta.ClientTools.Localization.lookup(name.Substring(1));
                    }
                    ;
                }
            }

            if (!dasdboard.Title.ShowMasterFilterState)
            {
                rowFilter.Visibility = Visibility.Collapsed;
            }

            XElement data = e.Dashboard.UserData;

            if (data != null)
            {
                var state = data.Element("DashboardState");
                if (state != null)
                {
                    dState.LoadFromXml(XDocument.Parse(state.Value));
                }

                var fixedComps = data.Element("FixedCompanies");
                if (fixedComps != null)
                {
                    fixedCompanies = null;
                    var rootelement = XElement.Parse(fixedComps.ToString());
                    foreach (var el in rootelement.Elements())
                    {
                        var fxdComps = XDocument.Parse(el.ToString()).Elements("FixedCompany")
                                       .Select(p => new FixedCompany
                        {
                            CompanyId      = int.Parse(p.Element("CompanyId").Value),
                            DatasourceName = p.Element("DatasourceName").Value
                        }).ToList();
                        if (fixedCompanies != null)
                        {
                            fixedCompanies.AddRange(fxdComps);
                        }
                        else
                        {
                            fixedCompanies = fxdComps;
                        }
                    }

                    if (fixedCompanies != null)
                    {
                        for (int i = 0; i < fixedCompanies.Count; i++)
                        {
                            var comp     = CWDefaultCompany.loadedCompanies.FirstOrDefault(x => x.CompanyId == fixedCompanies[i].CompanyId) as Company;
                            var openComp = OpenFixedCompany(comp).GetAwaiter().GetResult();
                            if (openComp != null)
                            {
                                openComp.GenerateUserType();
                                LoadListOfTableTypes(openComp);
                            }
                            else
                            {
                                UnicontaMessageBox.Show(Uniconta.ClientTools.Localization.lookup("UserNoAccessToCompany"), Uniconta.ClientTools.Localization.lookup("Information"));
                            }
                        }
                    }
                }

                var ldOnOpn = data.Element("LoadOnOpen");
                if (ldOnOpn != null)
                {
                    LoadOnOpen = bool.Parse(ldOnOpn.Value);
                }

                var userId = data.Element("LogedInUserIdFilter");
                if (userId != null)
                {
                    UserIdPropName = userId.Value;
                }

                var filters = data.Element("Filters");
                if (filters != null)
                {
                    var filtersBytes = Convert.FromBase64String(filters.Value);
                    var r            = StreamingManagerReuse.Create(filtersBytes);
                    int version      = r.readByte();
                    if (version != 0)
                    {
                        if (version < 3 && r.readBoolean())
                        {
                            int filterCount = (int)StreamingManager.readNum(r);
                            for (int i = 0; i < filterCount; i++)
                            {
                                var key = r.readString();
                                List <PropValuePair> propVal = new List <PropValuePair>();
                                var arrpropval = (PropValuePair[])r.ToArray(typeof(PropValuePair));
                                propVal = arrpropval.ToList();
                                lstOfFilters.Add(key, arrpropval);
                            }
                        }
                        else
                        {
                            int filterCount = (int)StreamingManager.readNum(r);
                            for (int i = 0; i < filterCount; i++)
                            {
                                var key       = r.readString();
                                var arrFilter = (FilterProperties[])r.ToArray(typeof(FilterProperties));
                                lstOfNewFilters.Add(key, arrFilter.ToList());
                            }
                        }
                    }
                    if (r.readBoolean())
                    {
                        if (version < 3)
                        {
                            int sortCount = (int)r.readNum();
                            for (int i = 0; i < sortCount; i++)
                            {
                                var          key      = r.readString();
                                var          arrSort  = (SortingProperties[])r.ToArray(typeof(SortingProperties));
                                FilterSorter propSort = new FilterSorter(arrSort);
                                lstOfSorters.Add(key, propSort);
                            }
                        }
                    }
                    r.Release();
                }
            }
            else
            {
                LoadOnOpen = true;  // for old saved dashboards
            }
            if (LoadOnOpen)
            {
                foreach (var ds in e.Dashboard.DataSources)
                {
                    dataSourceLoadingParams.Add(ds.ComponentName);
                }
            }
        }