Shared repository folder item fix

Ginger/Ginger/AutomatePageLib/AddActionMenu/SharedRepositoryLib/ActionsRepositoryPage.xaml.cs

@@ -78,7 +78,7 @@ private void SetGridAndTreeData()
             {
                 xActionListView.DataSourceList = mActionsFolder.GetFolderItems();
             }
-            xActionListView.SetFolderTreeRoot(new SharedActionsFolderTreeItem(mActionsFolder));
+            xActionListView.SetFolderTreeRootFactory(() => new SharedActionsFolderTreeItem(mActionsFolder));
             xActionListView.IsToggleButtonVisible = true;
         }
 

Ginger/Ginger/AutomatePageLib/AddActionMenu/SharedRepositoryLib/ActivitiesGroupsRepositoryPage.xaml.cs

@@ -74,7 +74,7 @@ private void SetGridAndTreeData()
             {
                 xActivitiesGroupsRepositoryListView.DataSourceList = mActivitiesGroupFolder.GetFolderItems();
             }
-            xActivitiesGroupsRepositoryListView.SetFolderTreeRoot(new SharedActivitiesGroupsFolderTreeItem(mActivitiesGroupFolder));
+            xActivitiesGroupsRepositoryListView.SetFolderTreeRootFactory(() => new SharedActivitiesGroupsFolderTreeItem(mActivitiesGroupFolder));
             xActivitiesGroupsRepositoryListView.IsToggleButtonVisible = true;
         }
 

Ginger/Ginger/AutomatePageLib/AddActionMenu/SharedRepositoryLib/ActivitiesRepositoryPage.xaml.cs

@@ -134,7 +134,7 @@ private void SetGridAndTreeData()
                 xActivitiesRepositoryListView.DataSourceList = mActivitiesFolder.GetFolderItems();
             }
 
-            xActivitiesRepositoryListView.SetFolderTreeRoot(new SharedActivitiesFolderTreeItem(mActivitiesFolder));
+            xActivitiesRepositoryListView.SetFolderTreeRootFactory(() => new SharedActivitiesFolderTreeItem(mActivitiesFolder));
             xActivitiesRepositoryListView.IsToggleButtonVisible = true;
         }
 

Ginger/Ginger/AutomatePageLib/AddActionMenu/SharedRepositoryLib/AddItemToRepositoryWizard/UploadItemsSelectionPage.xaml.cs

@@ -29,6 +29,10 @@ limitations under the License.
 using Amdocs.Ginger.UserControls;
 using GingerCore.Activities;
 using GingerCore.Variables;
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
 
 namespace Ginger.Repository.ItemToRepositoryWizard
 {
@@ -37,15 +41,99 @@ namespace Ginger.Repository.ItemToRepositoryWizard
     /// </summary>
     public partial class UploadItemsSelectionPage : Page, IWizardPage
     {
+        /// <summary>
+        /// Converter to invert boolean to visibility (true -> Collapsed, false -> Visible)
+        /// </summary>
+        private class BoolToVisibilityInvertConverter : IValueConverter
+        {
+            public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+            {
+                if (value is bool boolValue)
+                {
+                    return boolValue ? Visibility.Collapsed : Visibility.Visible;
+                }
+                return Visibility.Visible; // Default to visible if not a bool
+            }
+
+            public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+            {
+                if (value is Visibility visibility)
+                {
+                    return visibility != Visibility.Visible;
+                }
+                return false;
+            }
+        }
         public UploadItemToRepositoryWizard UploadItemToRepositoryWizard;
         public UploadItemsValidationPage itemValidate;
         bool isConvertPage = false;
+        ObservableList<UploadItemSelection> mItemsList;
+
         public UploadItemsSelectionPage(ObservableList<UploadItemSelection> items, bool isConvert)
         {
             InitializeComponent();
             isConvertPage = isConvert;
+            mItemsList = items;
             SetSelectedItemsGridView();
             itemSelectionGrid.DataSourceList = items;
+
+            // Listen to ItemUploadType changes to show/hide folder column dynamically
+            items.CollectionChanged += Items_CollectionChanged;
+            foreach (var item in items)
+            {
+                item.PropertyChanged += Item_PropertyChanged;
+            }
+
+            // Update folder column visibility after grid is loaded
+            this.Loaded += UploadItemsSelectionPage_Loaded;
+        }
+
+        private void UploadItemsSelectionPage_Loaded(object sender, RoutedEventArgs e)
+        {
+            // Initial update of folder column visibility
+            UpdateFolderColumnVisibility();
+        }
+
+        private void Items_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
+        {
+            if (e.NewItems != null)
+            {
+                foreach (UploadItemSelection item in e.NewItems)
+                {
+                    item.PropertyChanged += Item_PropertyChanged;
+                }
+            }
+            if (e.OldItems != null)
+            {
+                foreach (UploadItemSelection item in e.OldItems)
+                {
+                    item.PropertyChanged -= Item_PropertyChanged;
+                }
+            }
+            UpdateFolderColumnVisibility();
+        }
+
+        private void Item_PropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if (e.PropertyName == nameof(UploadItemSelection.ItemUploadType) ||
+                e.PropertyName == nameof(UploadItemSelection.IsOverrite))
+            {
+                UpdateFolderColumnVisibility();
+            }
+        }
+
+        private void UpdateFolderColumnVisibility()
+        {
+            // Show folder column only if there's at least one item that is NOT overwrite
+            bool shouldShowFolderColumn = mItemsList.Any(item => !item.IsOverrite);
+
+            var folderColumn = itemSelectionGrid.grdMain.Columns.FirstOrDefault(c =>
+                c.Header != null && c.Header.ToString() == "Add to Folder");
+
+            if (folderColumn != null)
+            {
+                folderColumn.Visibility = shouldShowFolderColumn ? Visibility.Visible : Visibility.Collapsed;
+            }
         }
 
         private void SetSelectedItemsGridView()
@@ -165,6 +253,13 @@ private DataTemplate CreateSelectFolderTemplate()
             panel.SetValue(FrameworkElement.HorizontalAlignmentProperty, HorizontalAlignment.Stretch);
             panel.SetValue(FrameworkElement.VerticalAlignmentProperty, VerticalAlignment.Center);
 
+            //// Hide folder selection UI for overwrite items (folder cannot be changed during overwrite)
+            //panel.SetBinding(UIElement.VisibilityProperty, new Binding(nameof(UploadItemSelection.IsOverrite))
+            //{
+            //    Converter = new BoolToVisibilityInvertConverter(),
+            //    Mode = BindingMode.OneWay
+            //});
+
             var txt = new FrameworkElementFactory(typeof(TextBlock));
             txt.SetValue(TextBlock.VerticalAlignmentProperty, VerticalAlignment.Center);
             txt.SetValue(TextBlock.MarginProperty, new Thickness(0, 0, 6, 0));

Ginger/Ginger/UserControlsLib/UCListView/UcListView.xaml.cs

@@ -124,6 +124,7 @@ public bool IsToggleButtonVisible
 
         bool mFolderViewActive = false;
         ITreeViewItem mFolderTreeRoot;
+        Func<ITreeViewItem> mFolderTreeRootFactory;
         CancellationTokenSource? mTreeSearchCts;
 
         public void SetFolderTreeRoot(ITreeViewItem root)
@@ -135,6 +136,17 @@ public void SetFolderTreeRoot(ITreeViewItem root)
                 xFolderTreeView.AddItem(mFolderTreeRoot);
             }
         }
+
+        public void SetFolderTreeRootFactory(Func<ITreeViewItem> factory)
+        {
+            mFolderTreeRootFactory = factory;
+            mFolderTreeRoot = factory();
+            if (xFolderTreeView != null)
+            {
+                xFolderTreeView.ClearTreeItems();
+                xFolderTreeView.AddItem(mFolderTreeRoot);
+            }
+        }
         public UcListView()
         {
             InitializeComponent();
@@ -401,11 +413,71 @@ NotifyCollectionChangedAction.Remove or
                     NotifyCollectionChangedAction.Move)
                 {
                     OnUcListViewEvent(UcListViewEventArgs.eEventType.UpdateIndex);
+
+                    // Refresh folder tree view when items are added/removed/modified
+                    if (mFolderTreeRoot != null && xFolderTreeView != null)
+                    {
+                        RefreshFolderTreeView();
+                    }
                 }
                 UpdateTitleListCount();
             });
         }
 
+        private void RefreshFolderTreeView()
+        {
+            try
+            {
+                this.Dispatcher.Invoke(() =>
+                {
+                    if (xFolderTreeView != null && xFolderTreeView.Tree != null && xFolderTreeView.Tree.Items.Count > 0)
+                    {
+                        // Create a fresh tree root to avoid cached children
+                        if (mFolderTreeRootFactory != null)
+                        {
+                            mFolderTreeRoot = mFolderTreeRootFactory();
+                        }
+
+                        if (mFolderTreeRoot != null)
+                        {
+                            xFolderTreeView.ClearTreeItems();
+                            xFolderTreeView.AddItem(mFolderTreeRoot);
+                        }
+                        // Refresh all expanded nodes in the tree
+                        RefreshExpandedTreeNodes(xFolderTreeView.Tree.Items[0] as TreeViewItem);
+                    }
+                });
+            }
+            catch (Exception ex)
+            {
+                Reporter.ToLog(eLogLevel.ERROR, "Failed to refresh folder tree view", ex);
+            }
+        }
+
+        private void RefreshExpandedTreeNodes(TreeViewItem treeNode)
+        {
+            if (treeNode == null)
+            {
+                return;
+            }
+
+            if (treeNode.IsExpanded && treeNode.Items.Count > 0)
+            {
+                var firstChild = treeNode.Items[0] as TreeViewItem;
+                if (firstChild != null)
+                {
+                    xFolderTreeView.RefreshTreeViewItemChildrens(treeNode);
+                }
+
+                // Recursively refreshing child nodes
+                var childItems = treeNode.Items.Cast<TreeViewItem>().ToList();
+                foreach (var childNode in childItems)
+                {
+                    RefreshExpandedTreeNodes(childNode);
+                }
+            }
+        }
+
         private void UpdateTitleListCount()
         {
             this.Dispatcher.Invoke(() =>
@@ -1315,6 +1387,19 @@ private void xToggleBtn_Click(object sender, RoutedEventArgs e)
                 // ensure folders + items are presented for current tab root
                 xFolderTreeView.EnableDragDrop = true;
                 xFolderTreeView.TreeChildFolderOnly = false;
+
+                // Refresh the tree to show latest items from repository
+                // Create a fresh tree root to avoid cached children
+                if (mFolderTreeRootFactory != null)
+                {
+                    mFolderTreeRoot = mFolderTreeRootFactory();
+                }
+
+                if (mFolderTreeRoot != null)
+                {
+                    xFolderTreeView.ClearTreeItems();
+                    xFolderTreeView.AddItem(mFolderTreeRoot);
+                }
             }
             else
             {