public Authenticate(FrwUser user, bool isAuthenticate, FrwCompany[] companies, FrwCompany defaultCompany)
 {
     User = user;
     IsAuthenticate = isAuthenticate;
     Companies = companies;
     DefaultCompany = defaultCompany;
 }
        public Authenticate(FrwUser user, bool isAuthenticate)
            : this(user, isAuthenticate, null, null)
        {

        }
        internal static PagePermission[] UserPagePermissions(FrwUser frwUser)
        {
            List<PagePermission> pagePermissionList = new List<PagePermission>();

            Conjunction conjUserProfile = new Conjunction();
            conjUserProfile.Add(Expression.Eq("objIdCompany", frwUser.objIdCompany));
            conjUserProfile.Add(Expression.Eq("objIdUser", frwUser));
            FrwUserProfile[] entityUserProfiles = FrwUserProfile.FindAll(conjUserProfile);
            if (entityUserProfiles != null)
            {
                foreach (FrwProfile objIdProfile in entityUserProfiles.Select(x => x.objIdProfile))
                {
                    Conjunction conjProfileFilter = new Conjunction();
                    conjProfileFilter.Add(Expression.Eq("objIdCompany", frwUser.objIdCompany));
                    conjProfileFilter.Add(Expression.Eq("objIdProfile", objIdProfile));
                    FrwProfileWindow[] entityProfileWindows = FrwProfileWindow.FindAll(conjProfileFilter);
                    if (entityProfileWindows != null)
                    {
                        foreach (FrwProfileWindow objIdProfileWindow in entityProfileWindows)
                        {
                            PagePermission pagePermission = pagePermissionList.FirstOrDefault(x => x.PageId == objIdProfileWindow.objIdWindow.IdWindow);
                            if (pagePermission != null)
                            {
                                // Validação de permissão pela negativa, caso algum perfil tiver, poderá bloquear o acesso.
                                pagePermission.IsReadOnly = objIdProfileWindow.IsReadOnly.Value ? pagePermission.IsReadOnly : objIdProfileWindow.IsReadOnly.Value;
                                pagePermission.IsPreview = objIdProfileWindow.IsPreview.Value ? pagePermission.IsPreview : objIdProfileWindow.IsPreview.Value;
                            }
                            else
                            {
                                pagePermissionList.Add(new PagePermission(objIdProfileWindow.objIdWindow.IdWindow, 
                                                                        objIdProfileWindow.objIdWindow.WindowEnum,
                                                                        objIdProfileWindow.objIdWindow.WindowTitle)
                                {
                                    IsReadOnly = objIdProfileWindow.IsReadOnly.Value,
                                    IsPreview = objIdProfileWindow.IsPreview.Value
                                });
                            }
                        }
                    }
                }
            }

            return pagePermissionList.ToArray();
        }
        internal static ComponentPermission[] UserComponentPermissions(FrwUser frwUser)
        {
            List<ComponentPermission> componentPermissionList = new List<ComponentPermission>();

            Conjunction conjUserProfile = new Conjunction();
            conjUserProfile.Add(Expression.Eq("objIdCompany", frwUser.objIdCompany));
            conjUserProfile.Add(Expression.Eq("objIdUser", frwUser));
            FrwUserProfile[] entityUserProfiles = FrwUserProfile.FindAll(conjUserProfile);
            if (entityUserProfiles != null)
            {
                foreach (FrwProfile objIdProfile in entityUserProfiles.Select(x => x.objIdProfile))
                {
                    Conjunction conjProfileFilter = new Conjunction();
                    conjProfileFilter.Add(Expression.Eq("objIdCompany", frwUser.objIdCompany));
                    conjProfileFilter.Add(Expression.Eq("objIdProfile", objIdProfile));

                    FrwProfileComponent[] entityProfileComponents = FrwProfileComponent.FindAll(conjProfileFilter);
                    foreach (FrwProfileComponent objIdProfileComponent in entityProfileComponents)
                    {
                        ComponentPermission componentPermission = componentPermissionList.FirstOrDefault(x => x.ComponentId == objIdProfileComponent.objIdComponent.IdComponent);
                        if (componentPermission != null)
                        {
                            // Validação de permissão pela negativa.
                            componentPermission.IsEnabled = objIdProfileComponent.IsEnable.Value ? componentPermission.IsEnabled : objIdProfileComponent.IsEnable.Value;
                            componentPermission.IsVisible = objIdProfileComponent.IsVisible.Value ? componentPermission.IsVisible : objIdProfileComponent.IsVisible.Value;
                        }
                        else
                        {
                            componentPermissionList.Add(new ComponentPermission(objIdProfileComponent.objIdComponent.objIdWindow.IdWindow,
                                                                                objIdProfileComponent.objIdComponent.objIdWindow.WindowEnum,
                                                                                objIdProfileComponent.objIdComponent.IdComponent,
                                                                                objIdProfileComponent.objIdComponent.ComponentNameId)
                            {
                                IsEnabled = objIdProfileComponent.IsEnable.Value,
                                IsVisible = objIdProfileComponent.IsVisible.Value
                            });
                        }
                    }
                }
            }

            return componentPermissionList.ToArray();
        }
        public HtmlGenericControl MainMenuBar(FrwUser loggedUser)
        {
            HtmlGenericControl mainMenuBar = new HtmlGenericControl("ul");
            mainMenuBar.Attributes.Add("class", "MainMenuBar");

            #region UL MainMenuBar

            ICriterion query = Expression.And(Expression.Eq("IsVisible", StateVisibleEnum.Yes), Expression.IsNull("objIdParent"));
            FrwMenu[] frwMenuRootList = FrwMenu.FindAll(Order.Asc("Sequence"), query);

            #region Menu Item

            HtmlGenericControl menuItemRoot = this.CreateMenuItem(Title);
            HtmlGenericControl menuItemsBox = this.CreateMenuItemItems(frwMenuRootList);

            #endregion Menu Item
            mainMenuBar.Controls.Add(menuItemRoot);

            #region Menu Item WindowFinder

            // TODO: WindowFinderInput foi comentado.
            // HtmlGenericControl menuItemWindowFinder = this.CreateMenuItemWindowFinder();

            #endregion Menu Item WindowFinder
            // mainMenuBar.Controls.Add(menuItemWindowFinder);

            #region Items Sub Menus
            foreach (FrwMenu item in frwMenuRootList)
            {
                HtmlGenericControl subMenu = this.CreateMenuItemItemSubMenu(item);

                if (subMenu != null)
                {
                    menuItemsBox.Controls.Add(this.CreateMenuItemItem(item));
                    mainMenuBar.Controls.Add(subMenu);
                }
            }

            menuItemRoot.Controls.Add(menuItemsBox);
            #endregion Items Sub Menus

            #endregion UL MainMenuBar

            return mainMenuBar;
        }