530 lines
20 KiB
C#
530 lines
20 KiB
C#
using System.ComponentModel;
|
|
using System.ComponentModel.Composition;
|
|
using System.Threading.Tasks;
|
|
using DTS.Common.Events;
|
|
using GroupList.Model;
|
|
using DTS.Common.Interface.Groups.GroupTemplateList;
|
|
using DTS.Common.Enums.Groups.GroupList;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System;
|
|
using System.Collections.Specialized;
|
|
using System.Linq;
|
|
using DTS.Common.Events.Groups.GroupList;
|
|
using DTS.Common.Interface.Groups.GroupList;
|
|
using System.Windows;
|
|
using DTS.Common.Storage;
|
|
using DTS.Common.Interface.Groups;
|
|
using Prism.Events;
|
|
using Prism.Regions;
|
|
using Unity;
|
|
using DTS.Common.Interactivity;
|
|
|
|
// ReSharper disable CheckNamespace
|
|
// ReSharper disable MemberCanBePrivate.Global
|
|
// ReSharper disable InconsistentNaming
|
|
|
|
namespace GroupList
|
|
{
|
|
/// <summary>
|
|
/// this class handles GroupList functionality
|
|
/// </summary>
|
|
[PartCreationPolicy(CreationPolicy.Shared)]
|
|
public class GroupListViewModel : IGroupListViewModel
|
|
{
|
|
/// <summary>
|
|
/// The GroupList view
|
|
/// </summary>
|
|
public IGroupListView View { get; set; }
|
|
private IEventAggregator _eventAggregator { get; }
|
|
private IRegionManager _regionManager;
|
|
private IUnityContainer UnityContainer { get; }
|
|
|
|
public InteractionRequest<Notification> NotificationRequest { get; }
|
|
public InteractionRequest<Confirmation> ConfirmationRequest { get; }
|
|
|
|
/// <inheritdoc />
|
|
/// <summary>
|
|
/// Occurs when a property value changes.
|
|
/// </summary>
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
public void OnPropertyChanged(string propertyName)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
|
|
#region constructors and initializers
|
|
/// <summary>
|
|
/// Creates a new instance of the GroupListViewModel
|
|
/// </summary>
|
|
/// <param name="view"></param>
|
|
/// <param name="regionManager">The logical placeholder defined within the application's UI (in the shell or within views) into which views are displayed.</param>
|
|
/// <param name="eventAggregator">The EventAggregator which allows different components to publish/subscribe to events without being coupled to each other.</param>
|
|
/// <param name="unityContainer">The unityContainer.</param>
|
|
public GroupListViewModel(IGroupListView view, IRegionManager regionManager,
|
|
IEventAggregator eventAggregator, IUnityContainer unityContainer)
|
|
{
|
|
View = view;
|
|
View.DataContext = this;
|
|
|
|
NotificationRequest = new InteractionRequest<Notification>();
|
|
ConfirmationRequest = new InteractionRequest<Confirmation>();
|
|
|
|
_eventAggregator = eventAggregator;
|
|
UnityContainer = unityContainer;
|
|
_regionManager = regionManager;
|
|
_eventAggregator.GetEvent<RaiseNotification>().Subscribe(OnRaiseNotification);
|
|
_eventAggregator.GetEvent<BusyIndicatorChangeNotification>()
|
|
.Subscribe(OnBusyIndicatorNotification, ThreadOption.PublisherThread, true);
|
|
SelectedGroupItems = new ObservableCollection<IGroup>();
|
|
}
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
public void ClearAllFilters()
|
|
{
|
|
_filterByField.Clear();
|
|
}
|
|
public void MouseDoubleClick(int index)
|
|
{
|
|
if (index >= 0 && index < Groups.Length && SelectedGroupItems.Count == 1)
|
|
{
|
|
_eventAggregator.GetEvent<GroupListEditGroupEvent>().Publish(Groups[index].Id);
|
|
}
|
|
}
|
|
|
|
public void Filter(string term)
|
|
{
|
|
CurrentSearchTerm = term;
|
|
Sort(_sortField.ToString(), false);
|
|
}
|
|
|
|
public IGroup GetGroup(int? id, bool updateTags = true)
|
|
{
|
|
if (id >= 0)
|
|
{
|
|
if (updateTags)
|
|
{
|
|
//Update the Tags in case they were modified by a different user
|
|
DTS.Common.Classes.Tags.TagsInstance.GetTagsInstance(DbOperations.TagsGet).UpdateList(DbOperations.TagsGet);
|
|
}
|
|
var groups = Group.GetAllGroups(id);
|
|
if (groups.Any())
|
|
{
|
|
return groups[0];
|
|
}
|
|
}
|
|
return new Group();
|
|
}
|
|
|
|
public IGroup GetGroup(string displayName)
|
|
{
|
|
//Get all of the groups with this DisplayName. This consists of both embedded and non-embedded
|
|
//if it was a pre-2.0 static Group or just the embedded, if it was a pre-2.0 Added Group.
|
|
//If the Group was first created in 2.0, it may have both embedded and non-embedded or just embedded.
|
|
var groups = Group.GetAllGroups(displayName);
|
|
foreach (var group in groups)
|
|
{
|
|
if (!group.Embedded)
|
|
{
|
|
//Return the corresponding non-embedded Group
|
|
return group;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public IGroup[] GetGroups(int[] ids)
|
|
{
|
|
var allGroups = Group.GetAllGroups().ToList();
|
|
for (var i = allGroups.Count - 1; i >= 0; i--)
|
|
{
|
|
if (ids.Contains(allGroups[i].Id)) { continue; }
|
|
allGroups.RemoveAt(i);
|
|
}
|
|
return allGroups.ToArray();
|
|
}
|
|
public IGroup[] GetAllGroups()
|
|
{
|
|
var allGroups = Group.GetAllGroups();
|
|
return allGroups;
|
|
}
|
|
public void DeleteGroups(int[] ids)
|
|
{
|
|
try
|
|
{
|
|
foreach (var id in ids)
|
|
{
|
|
//Set any embedded Groups' that have the to-be-deleted
|
|
//Group's Id as their StaticGroupId to null.
|
|
var relatedEmbeddedGroups = Group.GetAllRelatedEmbeddedGroups(id);
|
|
foreach (var embeddedGroup in relatedEmbeddedGroups)
|
|
{
|
|
Group.SetNullStaticGroupId(embeddedGroup);
|
|
}
|
|
|
|
Group.Delete(id);
|
|
}
|
|
|
|
var list = AllGroups.ToList();
|
|
for (var i = AllGroups.Length - 1; i >= 0; i--)
|
|
{
|
|
if (ids.Contains(AllGroups[i].Id))
|
|
{
|
|
list.RemoveAt(i);
|
|
}
|
|
}
|
|
|
|
AllGroups = list.ToArray();
|
|
Filter(CurrentSearchTerm);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_eventAggregator.GetEvent<PageErrorEvent>().Publish(new PageErrorArg(new[] { ex.Message }, Page));
|
|
}
|
|
|
|
}
|
|
|
|
public IGroup CreateGroup()
|
|
{
|
|
return new Group(true);
|
|
}
|
|
public IGroup CreateGroup(System.Data.SqlClient.SqlDataReader reader, List<string> includedHardwareStringList, List<int> dasIdList)
|
|
{
|
|
return new Group(reader, includedHardwareStringList, dasIdList);
|
|
}
|
|
|
|
public IGroup CreateGroup(IGroupDbRecord groupRecord, List<string> includedHardwareStringList, List<int> dasIdList)
|
|
{
|
|
return new Group(groupRecord, includedHardwareStringList, dasIdList);
|
|
}
|
|
|
|
public IGroup CreateGroup(List<string> includedHardwareStringList)
|
|
{
|
|
return new Group(includedHardwareStringList);
|
|
}
|
|
|
|
public void Filter(object tag, string term)
|
|
{
|
|
if (!Enum.TryParse((string)tag, out GroupFields field)) return;
|
|
_filterByField[field] = term;
|
|
_sortField = field;
|
|
Filter(term);
|
|
}
|
|
|
|
public void OnSetActive(object page, bool groupTile, object o)
|
|
{
|
|
try
|
|
{
|
|
var currentUser = (DTS.Slice.Users.User)o;
|
|
Page = page;
|
|
var groups = Group.GetAllGroups().Where(@group => currentUser.Role == DTS.Slice.Users.User.DefaultRoles.Administrator || currentUser.TagCompatible(@group.TagIDs)).ToList();
|
|
if (groupTile)
|
|
{
|
|
AllGroups = groups.ToArray();
|
|
Task.Run(() => GetTestSetupListsAsync());
|
|
}
|
|
else
|
|
{
|
|
AllGroups = groups.ToArray();
|
|
Sort(_sortField.ToString(), false);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_eventAggregator.GetEvent<PageErrorEvent>().Publish(new PageErrorArg(new[] { ex.Message }, Page));
|
|
}
|
|
}
|
|
|
|
private void GetTestSetupListsAsync()
|
|
{
|
|
_eventAggregator.GetEvent<AppStatusEvent>().Publish(AppStatusArg.Busy);
|
|
var groups = AllGroups.ToArray();
|
|
|
|
|
|
_eventAggregator.GetEvent<ProgressBarEvent>().Publish(new ProgressBarEventArg()
|
|
{ ProgressBarText = $"Getting groups", SetText = true });
|
|
|
|
groups.AsParallel().ForAll(g =>
|
|
{
|
|
_eventAggregator.GetEvent<ProgressBarEvent>().Publish(new ProgressBarEventArg()
|
|
{ ProgressBarText = $"Getting group {g.DisplayName}", SetText = true });
|
|
g.SetTestSetupLists();
|
|
});
|
|
|
|
Application.Current.Dispatcher.Invoke(new Action(() =>
|
|
{
|
|
Sort(_sortField.ToString(), false);
|
|
}));
|
|
|
|
_eventAggregator.GetEvent<ProgressBarEvent>().Publish(new ProgressBarEventArg()
|
|
{ ProgressBarText = $"Waiting for user input", SetText = true });
|
|
_eventAggregator.GetEvent<AppStatusEvent>().Publish(AppStatusArg.Available);
|
|
}
|
|
public void Unset()
|
|
{
|
|
AllGroups = new IGroup[0];
|
|
Groups = new IGroup[0];
|
|
ClearAllFilters();
|
|
_eventAggregator.GetEvent<ListViewStatusEvent>()
|
|
.Publish(new ListViewStatusArg(ListViewStatusArg.ListViewStatus.Unloaded, ListViewId));
|
|
}
|
|
public void Sort(object o, bool bColumnClick)
|
|
{
|
|
if (!(o is string s)) { return; }
|
|
if (!Enum.TryParse(s, out GroupFields tag)) { return; }
|
|
|
|
if (bColumnClick)
|
|
{
|
|
if (tag != _sortField)
|
|
{
|
|
_sortField = tag;
|
|
_sortAscending = true;
|
|
}
|
|
else
|
|
{
|
|
_sortAscending = !_sortAscending;
|
|
}
|
|
}
|
|
|
|
_comparer.SortAscending = _sortAscending;
|
|
_comparer.SortField = _sortField;
|
|
var list = new List<IGroup>();
|
|
foreach (var group in AllGroups)
|
|
{
|
|
if (group.Filter(CurrentSearchTerm))
|
|
{
|
|
if (GroupFilter(group))
|
|
{
|
|
list.Add(group);
|
|
}
|
|
}
|
|
}
|
|
var originalList = list.ToList();
|
|
list.Sort(_comparer);
|
|
//this doesn't seem right, should just use the _sortField and sort ascending
|
|
//logic already present
|
|
//if (originalList.SequenceEqual(list) && originalList.Count > 1 &&
|
|
// !(_comparer.SortAscending && _comparer.SortField == GroupFields.LastModified))//AllGroups already ordered by lastmodified, ascending
|
|
//{
|
|
// //list was already in order. flip it for the user
|
|
// _sortAscending = !_sortAscending;
|
|
// _comparer.SortAscending = _sortAscending;
|
|
// list.Sort(_comparer);
|
|
//}
|
|
Groups = list.ToArray();
|
|
OnPropertyChanged("Groups");
|
|
}
|
|
|
|
private bool GroupFilter(IGroup group)
|
|
{
|
|
var fields = Enum.GetValues(typeof(GroupFields)).Cast<GroupFields>().ToArray();
|
|
foreach (var field in fields)
|
|
{
|
|
if (!_filterByField.ContainsKey(field)) { continue; }
|
|
var term = _filterByField[field];
|
|
if (string.IsNullOrWhiteSpace(term)) { continue; }
|
|
switch (field)
|
|
{
|
|
case GroupFields.DisplayName:
|
|
if (!(System.Globalization.CultureInfo.CurrentCulture.CompareInfo.IndexOf(group.DisplayName, term,
|
|
System.Globalization.CompareOptions.OrdinalIgnoreCase) >= 0))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
case GroupFields.Description:
|
|
if (!(System.Globalization.CultureInfo.CurrentCulture.CompareInfo.IndexOf(group.Description, term,
|
|
System.Globalization.CompareOptions.OrdinalIgnoreCase) >= 0))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
case GroupFields.ChannelCount:
|
|
if (!(System.Globalization.CultureInfo.CurrentCulture.CompareInfo.IndexOf(group.ChannelCount.ToString(), term,
|
|
System.Globalization.CompareOptions.OrdinalIgnoreCase) >= 0))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
case GroupFields.LastModified:
|
|
if (!(System.Globalization.CultureInfo.CurrentCulture.CompareInfo.IndexOf(group.LastModified.ToString(), term,
|
|
System.Globalization.CompareOptions.OrdinalIgnoreCase) >= 0))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
case GroupFields.LastModifiedBy:
|
|
if (!(System.Globalization.CultureInfo.CurrentCulture.CompareInfo.IndexOf(group.LastModifiedBy, term,
|
|
System.Globalization.CompareOptions.OrdinalIgnoreCase) >= 0))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
case GroupFields.AssociatedTestSetups:
|
|
{
|
|
var testSetups = new List<string>();
|
|
foreach (var assoc in group.AssociatedTestSetups) { testSetups.Add(assoc.Name); }
|
|
var s = string.Join(", ", testSetups.ToArray());
|
|
if (!(System.Globalization.CultureInfo.CurrentCulture.CompareInfo.IndexOf(s, term,
|
|
System.Globalization.CompareOptions.OrdinalIgnoreCase) >= 0))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
public void Cleanup()
|
|
{
|
|
}
|
|
|
|
public Task CleanupAsync()
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public void Initialize()
|
|
{
|
|
}
|
|
|
|
public void Initialize(object parameter)
|
|
{
|
|
}
|
|
|
|
public void Initialize(object parameter, object model)
|
|
{
|
|
}
|
|
|
|
public Task InitializeAsync()
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task InitializeAsync(object parameter)
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public void Activated()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Private Event handler for RaiseNotification event.
|
|
/// </summary>
|
|
private void OnBusyIndicatorNotification(bool eventArg)
|
|
{
|
|
IsBusy = eventArg;
|
|
}
|
|
|
|
private void FireSelectionChanged()
|
|
{
|
|
_eventAggregator.GetEvent<GroupListGroupSelectedEvent>().Publish(_selectedGroupItems.Select(grp => grp.Id).ToArray());
|
|
}
|
|
/// <summary>
|
|
/// Private Event handler for RaiseNotification event.
|
|
/// </summary>
|
|
private void OnRaiseNotification(NotificationContentEventArgs eventArgsWithTitle)
|
|
{
|
|
// The NotificationRequest.Raise triggers the Invoke() method of the PopupWindowAction object to show the NotificationWindow window
|
|
// Notification object expects a NotificationContentEventArgsWithoutTitle object and a Title string.
|
|
var eventArgsWithoutTitle = new NotificationContentEventArgs(eventArgsWithTitle.Message, "",
|
|
eventArgsWithTitle.Image, string.Empty);
|
|
|
|
NotificationRequest.Raise(new Notification
|
|
{
|
|
Content = eventArgsWithoutTitle,
|
|
Title = eventArgsWithTitle.Title
|
|
});
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
private readonly Dictionary<GroupFields, string> _filterByField = new Dictionary<GroupFields, string>();
|
|
private string CurrentSearchTerm = "";
|
|
public int SelectedGroupIndex { get; set; } = -1;
|
|
|
|
public ObservableCollection<IGroup> _selectedGroupItems;
|
|
public ObservableCollection<IGroup> SelectedGroupItems
|
|
{
|
|
get => _selectedGroupItems;
|
|
set
|
|
{
|
|
if (_selectedGroupItems != null)
|
|
{
|
|
_selectedGroupItems.CollectionChanged -= SelectedGroupItemsOnCollectionChanged;
|
|
}
|
|
_selectedGroupItems = value;
|
|
if (_selectedGroupItems != null)
|
|
{
|
|
_selectedGroupItems.CollectionChanged += SelectedGroupItemsOnCollectionChanged;
|
|
}
|
|
FireSelectionChanged();
|
|
}
|
|
}
|
|
|
|
private void SelectedGroupItemsOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs notifyCollectionChangedEventArgs)
|
|
{
|
|
if (DTS.Common.Enums.SelectedItemsStatus.GetUpdating(SelectedGroupItems)) { return; }
|
|
FireSelectionChanged();
|
|
}
|
|
private IGroup[] AllGroups { get; set; }
|
|
//sort by last modified descending by default
|
|
private bool _sortAscending = false;
|
|
private GroupFields _sortField = GroupFields.LastModified;
|
|
private readonly GroupComparer _comparer = new GroupComparer();
|
|
public IGroup[] Groups { get; set; }
|
|
public bool IsDirty { get; private set; }
|
|
private bool _isBusy;
|
|
|
|
public bool IsBusy
|
|
{
|
|
get => _isBusy;
|
|
set
|
|
{
|
|
_isBusy = value;
|
|
OnPropertyChanged("IsBusy");
|
|
}
|
|
}
|
|
|
|
private bool _isMenuIncluded;
|
|
|
|
public bool IsMenuIncluded
|
|
{
|
|
get => _isMenuIncluded;
|
|
set
|
|
{
|
|
_isMenuIncluded = value;
|
|
OnPropertyChanged("IsMenuIncluded");
|
|
}
|
|
}
|
|
|
|
private bool _isNavigationIncluded;
|
|
|
|
public bool IsNavigationIncluded
|
|
{
|
|
get => _isNavigationIncluded;
|
|
set
|
|
{
|
|
_isNavigationIncluded = value;
|
|
OnPropertyChanged("IsNavigationIncluded");
|
|
}
|
|
}
|
|
|
|
public string ListViewId => "GroupListView";
|
|
private object Page { get; set; }
|
|
#endregion Properties
|
|
|
|
#region Commands
|
|
|
|
#endregion
|
|
}
|
|
}
|