ru.coon 2.8.65 → 3.0.2

package/src/nav/MenuEntity.js

@@ -1,16 +1,17 @@
 Ext.define('Coon.nav.MenuEntity', {
     singleton: true,
-    menuItems: null,
-    isLoading: false,
-    promise: null,
+
+    privates: {
+        menuItems: [],
+    },
+
+    isLoading: true,
+
     get() {
-        if (typeof this.menuItems === 'object' && Array.isArray(this.menuItems) && this.isLoading === false) {
-            return new Promise((resolve) => {
-                resolve(this.menuItems);
-            });
-        } else if (!this.promise) {
-            this.isLoading = true;
-            this.promise = Coon.util.promisifyCmd('command.GetDynamicReportDataCommand', 'MENU_ALLITEMS')
+        if (!this.isLoading) {
+            return Promise.resolve(this.menuItems);
+        } else {
+            return Coon.util.promisifyCmd('command.GetDynamicReportDataCommand', 'MENU_ALLITEMS')
                 .then((data) => {
                     if (Array.isArray(data.list)) {
                         this.menuItems = data.list;
@@ -19,17 +20,24 @@ Ext.define('Coon.nav.MenuEntity', {
                     }
                     this.isLoading = false;
                     return this.menuItems;
-                }).finally(() => {
-                    this.promise = null;
+                }).catch((error) => {
+                    Coon.log.error(`ошибка начитывания меню навигации: ${JSON.stringify(error)}`);
+                    this.isLoading = false;
+                    return this.menuItems;
                 });
         }
-        return this.promise;
     },
 
-    isValid(uiElement) {
+    isValid(menuEntryCD) {
         return this.get().then((data) => {
-            return !!data.find((i) => i.UI_ELEMENT_CD === uiElement);
+            return !!data.find((i) => i.MENU_ENTRY_CD === menuEntryCD);
         });
     },
 
+    getMenuItem(menuEntryCD, property) {
+        return this.get().then((data) => {
+            const menuItem = data.find((i) => i.MENU_ENTRY_CD === menuEntryCD);
+            return property ? menuItem[property] : menuItem;
+        });
+    },
 });

package/src/nav/MenuFavoritesBar.js

@@ -0,0 +1,100 @@
+Ext.define('Coon.nav.menu.MenuFavoritesBar', {
+    extend: 'Ext.panel.Panel',
+    xtype: 'MenuFavoritesBar',
+    cls: 'MenuFavoritesBar',
+    layout: {
+        type: 'vbox',
+        align: 'stretch',
+    },
+    listeners: {
+        render: 'onRender',
+    },
+    items: [],
+    popupEl: null,
+    scrollable: true,
+
+    controller: {
+        init() {
+            Ext.on({
+                'nav:menuitemchange': {fn: this.onMenuItemChanged, scope: this},
+                'nav:favoriteitemschange': {
+                    fn: function() {
+                        this.renderFavoritesItems(true);
+                    },
+                    scope: this,
+                },
+                'nav:setvisiblefavoritepanel': {fn: (visible) => {
+                    this.getView().setVisible(!visible);
+                    this.onMenuItemChanged({MENU_ENTRY_CD: Ext.getApplication().appRouter?.lastRoute?.id});
+                }, scope: this},
+            });
+
+            this.renderFavoritesItems();
+        },
+
+        onRender() {
+            this.getView().setVisible(!Coon.userSettings.get('favoritePanelHidden'));
+        },
+
+        onMenuItemChanged(item) {
+            const menuItem = item && this.getView().down(`#${item.MENU_ENTRY_CD}`);
+            this.deselectAll();
+            if (menuItem) {
+                this.select(menuItem);
+            }
+        },
+
+        renderFavoritesItems(selectItem) {
+            this.getView().removeAll();
+            const props = Coon.nav.menu.FavoriteCfg.get().favorite || [];
+            Coon.nav.MenuEntity.get().then((menu) => {
+                const lastRoute = Ext.getApplication().appRouter?.lastRoute?.id;
+                menu.forEach((item) => {
+                    if (props.indexOf(item.MENU_ENTRY_CD) > -1) {
+                        this.addNewItem({
+                            WORKSPACE_DESCR: item.WORKSPACE_DESCR,
+                            text: item.MENU_ENTRY_DESCR,
+                            UI_ELEMENT_CD: item.UI_ELEMENT_CD,
+                            MENU_ENTRY_CD: item.MENU_ENTRY_CD,
+                            iconCls: item.MENU_ENTRY_ICON,
+                            selected: selectItem && lastRoute === item.MENU_ENTRY_CD ? 'selected' : '',
+                        });
+                    }
+                });
+            });
+        },
+
+        deselectAll() {
+            Ext.dom.Query.select('.selected', this.getView().el.dom).forEach((item) => item.classList.remove('selected'));
+        },
+
+        select(item) {
+            if (item.el) {
+                item.el.dom.firstElementChild.classList.add('selected');
+            }
+        },
+
+        addNewItem(item) {
+            const iconCls = item.iconCls ? item.iconCls : 'svg-icon svg-icon-attention';
+            return this.getView().add({
+                xtype: 'component',
+                itemId: item.MENU_ENTRY_CD,
+                iconCls: item.iconCls,
+                html: `<div  class="vb-item ${item.selected}">
+                            <i class="vb-icon ${iconCls} svg-icon-size-18 menu-item-main-icon"></i>
+                            <span class="menu-item-text-elem"> 
+                                <i class="vb-text svg-icon-size-18">${item.text}</i> 
+                            </span>
+                        </div>`,
+                listeners: {
+                    render: (c) => {
+                        c.getEl().dom.onclick = () => {
+                            Ext.fireEvent('nav:menuitemclick', item.MENU_ENTRY_CD);
+                        };
+                    },
+                },
+            });
+        },
+    },
+
+});

package/src/nav/MenuFavoritesBar.scss

@@ -0,0 +1,92 @@
+.menu-item-text-elem.selected{
+    background-color: #112b39;
+}
+.menu-item-text-elem.selected::before {
+    background-color: #9a2d2a;
+    content: " ";
+    position: absolute;
+    display: block;
+    left: 0;
+    top: 0;
+    width: 5px;
+    height: 100%;
+}
+.menu-item-text-elem{
+    cursor: pointer;
+    background-color: #2C5771;
+    height: 40px;
+    color: #fff;
+    position: absolute;
+    z-index: 999999999;
+    display: flex;
+    align-items: center;
+    top: 0px;
+    left: 40px;
+    .vb-icon{
+        background-color: #fff;
+        display: inline-block;
+        width: 40px;
+        height: 40px;
+    }
+    .vb-text{
+        color: #fff;
+        margin:0 20px 0 5px;
+        display: inline-block;
+        white-space: nowrap;
+    }
+}
+.MenuFavoritesBar{
+    width: 100% !important;
+    .menu-item-text-elem {
+        display: none;
+        .vb-text {
+            font-style: normal;
+        }
+    }
+    .vb-item:hover {
+        .menu-item-text-elem {
+            display: flex;
+        }
+    }
+    .x-panel-body {
+        scrollbar-width: none;
+        width: 100% !important;
+    }
+    .x-box-inner{
+        background-color: $base-color;
+        width: 40px !important;
+        overflow: visible;
+    }
+    .x-box-item {
+        width: 40px !important;
+    }
+    .vb-item{
+        height: 40px;
+        cursor: pointer;
+        .vb-icon{
+            background-color: #fff;
+            display: block;
+            width: 40px;
+            height: 40px;
+        }
+    }
+    .vb-item:hover{
+        background-color: #2C5771;
+    }
+    .vb-item.selected{
+        background-color: #112b39;
+        .menu-item-text-elem {
+            background-color: #112b39;
+        }
+    }
+    .vb-item.selected::before {
+        background-color: #9a2d2a;
+        content: " ";
+        position: absolute;
+        display: block;
+        left: 0;
+        top: 0;
+        width: 5px;
+        height: 100%;
+    }
+}

package/src/nav/editor/NavigateElementEditorView.js

@@ -4,9 +4,9 @@
  */
 
 Ext.define('Coon.nav.editor.NavigateElementEditorView', {
-    extend: 'Ext.container.Container',
+    extend: 'Ext.panel.Panel',
     xtype: 'NavigateElementEditorView',
-    ui: 'NavigateElementEditorView',
+    // ui: 'NavigateElementEditorView',
 
     viewModel: 'NavigateElementEditorViewModel',
 

package/src/nav/editor/workspace/NavWorkspaceListView.js

@@ -25,10 +25,7 @@ Ext.define('Coon.nav.editor.workspace.NavWorkspaceListView', {
         },
     },
 
-    title: `
-            <span class='titleNavWorkspaceList'> 
-                Список рабочих пространств
-            </span>`,
+    title: `Список рабочих пространств`,
 
     tbar: [
         {

package/src/nav/menu/WorkspaceMenuViewMinimized.js

@@ -0,0 +1,22 @@
+Ext.define('Coon.nav.menu.WorkspaceMenuViewMinimized', {
+    extend: 'Ext.list.Tree',
+    requires: [
+        'Ext.data.TreeStore'
+    ],
+    xtype: 'WorkspaceMenuViewMinimized',
+    ui: 'menu',
+    micro: true,
+    cls: 'WorkspaceMenuView',
+    listeners: {
+        itemcollapse: (cmp) => {
+            Ext.defer(() => {
+                cmp.updateLayout();
+            }, 300, this);
+        },
+    },
+    scrollable: true,
+    expanderFirst: false,
+    highlightPath: true,
+    expanderOnly: false,
+    singleExpand: true,
+});

package/src/overrides/panel/TabPanel.js

@@ -0,0 +1,36 @@
+/**
+ * Override класса 'Ext.tab.Panel'.
+ * Добавлен функционал:
+ *   - Подписка на событие 'dirtychange' на все items в tabpanel,
+ *   добавляющий/удаляющий дополнительный класс tabDirtyCls у tab.
+ *
+ * Стилизация вертикальных табов осуществлена добавлением "cls: 'coonVerticalTabpanel'" в конфигурацию tabpanel.
+ */
+Ext.define('Coon.overrides.panel.TabPanelOverride', {
+    override: 'Ext.tab.Panel',
+
+    tabDirtyCls: 'tab-dirty',
+
+    initComponent() {
+        this.callParent();
+        this.getLayout().getLayoutItems().forEach((tab) => {
+            tab.on('dirtychange', this.onCardDirtyChange.bind(this));
+        });
+    },
+
+    /**
+    * @param { component: Component, isDirty: boolean }
+    * Ставит/убирает CSS класс "tabDirtyCls" в зависимости от флага "isDirty" соответствующей табе
+    */
+    onCardDirtyChange(component, isDirty) {
+        if (!component.tab) {
+            return;
+        }
+        if (isDirty) {
+            component.tab.addCls(this.tabDirtyCls);
+        } else {
+            component.tab.removeCls(this.tabDirtyCls);
+        }
+    },
+});
+

package/src/overrides/panel/TabPanel.scss

@@ -0,0 +1,65 @@
+.coonVerticalTabpanel {
+    .x-tab-bar.x-tab-bar-vertical {
+        background-color: #fff;
+
+        .x-tab {
+            position: static !important;
+            padding: 8px 16px;
+            border-color: transparent;
+            color: var(--color);
+            text-transform: none;
+            max-width: 200px;
+
+            &.x-tab-left {
+                border-width: 0 0 0 4px;
+            }
+
+            &.x-tab-over {
+                background-color: #ececec;
+            }
+
+            &.x-tab-active,
+            &.x-tab-active.x-tab-focus {
+                border-color: $active-color-tec;
+                background-color: #F5F5F5;
+            }
+
+            .x-tab-inner {
+                text-wrap-mode: wrap;
+            }
+        }
+
+        .x-tab-text {
+            text-align: left;
+        }
+
+        .x-tab-inner {
+            --line-height: 16px;
+
+            color: var(--color);
+            font-weight: 400;
+            line-height: var(--line-height);
+        }
+    }
+
+    .tab-dirty {
+        position: relative;
+        .x-tab-inner {
+            position: relative;
+            overflow: visible;
+
+            &::before {
+                content: '';
+                display: block;
+                width: 5px;
+                height: 5px;
+                background: $base-color-light;
+                border-radius: 50%;
+                position: absolute;
+                left: -10px;
+                top: calc(1em / 2);
+                transform: translateY(-50%);
+            }
+        }
+    }
+}

package/src/report/component/ClearFiltersButton.js

@@ -14,7 +14,10 @@ Ext.define('Coon.report.component.ClearFiltersButton', {
     grid: null,
     handler() {
         if (this.grid) {
-            this.grid.clearFilters();
+            // clearFilters примешивается, если есть GridFiltersPlugin
+            if (Ext.isFunction(this.grid.clearFilters)) {
+                this.grid.clearFilters();
+            }
             this.grid.fireEvent('clearAllFilters');
         }
     },

package/src/report/component/CopyCellValueMenuItem.js

@@ -0,0 +1,18 @@
+Ext.define('Coon.report.component.CopyCellValueMenuItem', {
+    extend: 'Ext.menu.Item',
+    alias: 'widget.CopyCellValueMenuItem',
+    text: 'Копировать',
+    isItemHidden() {
+        const menu = this.parentMenu;
+        return !(menu.context && menu.context.hasContext);
+    },
+    isItemDisabled() {
+        return false;
+    },
+    handler() {
+        const menu = this.parentMenu;
+        if (menu.context && menu.context.td) {
+            Coon.util.copyToClipboard(menu.context.td.innerText);
+        }
+    },
+});