|
|
@@ -1,1600 +1,1061 @@
|
|
|
-using System;
|
|
|
+using Comal.Classes;
|
|
|
+using InABox.Clients;
|
|
|
+using InABox.Core;
|
|
|
+using InABox.WPF;
|
|
|
+using System;
|
|
|
using System.Collections.Generic;
|
|
|
-using System.Collections.ObjectModel;
|
|
|
using System.Globalization;
|
|
|
using System.Linq;
|
|
|
using System.Linq.Expressions;
|
|
|
using System.Reflection;
|
|
|
-using System.Threading;
|
|
|
+using System.Text;
|
|
|
using System.Threading.Tasks;
|
|
|
using System.Windows;
|
|
|
using System.Windows.Controls;
|
|
|
using System.Windows.Data;
|
|
|
+using System.Windows.Documents;
|
|
|
using System.Windows.Input;
|
|
|
+using System.Drawing;
|
|
|
using System.Windows.Media;
|
|
|
using System.Windows.Media.Imaging;
|
|
|
-using Comal.Classes;
|
|
|
-using InABox.Clients;
|
|
|
-using InABox.Core;
|
|
|
+using Color = System.Drawing.Color;
|
|
|
using InABox.DynamicGrid;
|
|
|
using InABox.Wpf;
|
|
|
-using InABox.WPF;
|
|
|
-using org.omg.CORBA;
|
|
|
+using MailKit.Search;
|
|
|
+using NPOI.SS.Formula.Functions;
|
|
|
+using System.ComponentModel;
|
|
|
+using System.Runtime.CompilerServices;
|
|
|
+using System.Collections.ObjectModel;
|
|
|
+using System.Collections.Specialized;
|
|
|
using Syncfusion.UI.Xaml.Kanban;
|
|
|
-using Color = System.Drawing.Color;
|
|
|
|
|
|
-namespace PRSDesktop
|
|
|
+namespace PRSDesktop;
|
|
|
+
|
|
|
+public class TasksByStatusColumn : INotifyPropertyChanged
|
|
|
{
|
|
|
- public class EmployeeModel
|
|
|
+ public string Category { get; }
|
|
|
+
|
|
|
+ public string Title { get; }
|
|
|
+
|
|
|
+ public int NumTasks { get => Tasks.Count; }
|
|
|
+
|
|
|
+ public double NumHours { get => Tasks.Sum(x => x.EstimatedTime.TotalHours); }
|
|
|
+
|
|
|
+ public ObservableCollection<TaskModel> Tasks { get; } = new();
|
|
|
+
|
|
|
+ public TasksByStatusColumn(string category, string title)
|
|
|
{
|
|
|
- public EmployeeModel(Guid id, string name, Guid thumbnail, BitmapImage image)
|
|
|
- {
|
|
|
- ID = id;
|
|
|
- Name = name;
|
|
|
- Image = image;
|
|
|
- ThumbnailID = thumbnail;
|
|
|
- }
|
|
|
+ Category = category;
|
|
|
+ Title = title;
|
|
|
|
|
|
- public Guid ID { get; set; }
|
|
|
- public string Name { get; set; }
|
|
|
- public BitmapImage Image { get; set; }
|
|
|
- public Guid ThumbnailID { get; set; }
|
|
|
+ Tasks.CollectionChanged += Tasks_CollectionChanged;
|
|
|
}
|
|
|
|
|
|
- public class StatusTasksHeaderTimeConverter : IValueConverter
|
|
|
+ private void Tasks_CollectionChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
|
|
|
{
|
|
|
- public static IEnumerable<TaskModel> Tasks { get; set; }
|
|
|
+ OnPropertyChanged(nameof(Tasks));
|
|
|
+ }
|
|
|
+
|
|
|
+ public event PropertyChangedEventHandler? PropertyChanged;
|
|
|
|
|
|
- public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
|
+ // Create the OnPropertyChanged method to raise the event
|
|
|
+ // The calling member's name will be used as the parameter.
|
|
|
+ protected void OnPropertyChanged([CallerMemberName] string? name = null)
|
|
|
+ {
|
|
|
+ PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
|
|
|
+
|
|
|
+ if(name == nameof(Tasks))
|
|
|
{
|
|
|
- if (Tasks == null)
|
|
|
- return "0:00";
|
|
|
+ OnPropertyChanged(nameof(NumTasks));
|
|
|
+ OnPropertyChanged(nameof(NumHours));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
|
|
|
- var dataContext = value as ColumnTag;
|
|
|
- if (dataContext == null)
|
|
|
- return "0:00";
|
|
|
+public class EmployeeModel
|
|
|
+{
|
|
|
+ public Guid ID { get; set; }
|
|
|
|
|
|
- var getter = dataContext.GetType().GetProperty("Column", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
|
- if (getter == null)
|
|
|
- return "0:00";
|
|
|
+ public string Name { get; set; }
|
|
|
|
|
|
- var column = (KanbanColumn)getter.GetValue(dataContext);
|
|
|
- if (column == null)
|
|
|
- return "0:00";
|
|
|
+ public BitmapImage? Image { get; set; }
|
|
|
|
|
|
- double result = 0.0F;
|
|
|
- foreach (var kanban in Tasks.Where(x => Equals(x.Category, column.Categories)))
|
|
|
- result += kanban.EstimatedTime.TotalHours;
|
|
|
- return string.Format("{0:F2}", result);
|
|
|
- }
|
|
|
+ public Guid ThumbnailID { get; set; }
|
|
|
|
|
|
- public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
|
- {
|
|
|
- throw new NotImplementedException();
|
|
|
- }
|
|
|
+ public EmployeeModel(Guid id, string name, Guid thumbnail, BitmapImage? image)
|
|
|
+ {
|
|
|
+ ID = id;
|
|
|
+ Name = name;
|
|
|
+ Image = image;
|
|
|
+ ThumbnailID = thumbnail;
|
|
|
}
|
|
|
+}
|
|
|
|
|
|
- public class BoolToVisibilityConverter : IValueConverter
|
|
|
+public class SuspendableObservableCollection<T> : ObservableCollection<T>
|
|
|
+{
|
|
|
+ private bool _notificationSupressed = false;
|
|
|
+ private bool _supressNotification = false;
|
|
|
+ public bool SupressNotification
|
|
|
{
|
|
|
- public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
|
+ get
|
|
|
{
|
|
|
- if (Equals(value, true))
|
|
|
- return Visibility.Visible;
|
|
|
- return Visibility.Collapsed;
|
|
|
+ return _supressNotification;
|
|
|
}
|
|
|
-
|
|
|
- public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
|
+ set
|
|
|
{
|
|
|
- throw new NotImplementedException();
|
|
|
+ _supressNotification = value;
|
|
|
+ if (_supressNotification == false && _notificationSupressed)
|
|
|
+ {
|
|
|
+ this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
|
|
|
+ _notificationSupressed = false;
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Interaction logic for KanbanPanel.xaml
|
|
|
- /// </summary>
|
|
|
- public partial class TasksByStatusControl : UserControl, ITaskControl
|
|
|
+ protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
|
|
|
{
|
|
|
-
|
|
|
- private enum Suppress
|
|
|
+ if (SupressNotification)
|
|
|
{
|
|
|
- This
|
|
|
+ _notificationSupressed = true;
|
|
|
+ return;
|
|
|
}
|
|
|
+ base.OnCollectionChanged(e);
|
|
|
+ }
|
|
|
+}
|
|
|
|
|
|
- private BitmapImage _attachimg = PRSDesktop.Resources.attachment.AsBitmapImage();
|
|
|
-
|
|
|
- private readonly ObservableCollection<EmployeeModel> _employeelist = new();
|
|
|
|
|
|
- private CoreTable _employees;
|
|
|
+/// <summary>
|
|
|
+/// Interaction logic for TasksByStatusControl.xaml
|
|
|
+/// </summary>
|
|
|
+public partial class TasksByStatusControl : UserControl, ITaskControl, INotifyPropertyChanged
|
|
|
+{
|
|
|
+ private enum Suppress
|
|
|
+ {
|
|
|
+ This
|
|
|
+ }
|
|
|
|
|
|
- public CoreTable _kanbans;
|
|
|
+ public SuspendableObservableCollection<TasksByStatusColumn> Columns { get; private set; } = new();
|
|
|
|
|
|
- private BitmapImage _lockimg = PRSDesktop.Resources.lock_sml.AsBitmapImage();
|
|
|
- private ObservableCollection<TaskModel> _models = new();
|
|
|
- private CoreTable _types;
|
|
|
+ private List<EmployeeModel> Employees = new();
|
|
|
|
|
|
- public List<string> CheckedKanbans = new();
|
|
|
+ public TasksByStatusControl()
|
|
|
+ {
|
|
|
+ InitializeComponent();
|
|
|
+ }
|
|
|
|
|
|
- // CoreUtils.FullGuid => All Staff
|
|
|
- // Guid.Empty => Unallocated
|
|
|
- // Anything Else => Actual Staff Member
|
|
|
- private Guid EmployeeID = Guid.Empty;
|
|
|
+ #region INotifyPropertyChanged
|
|
|
|
|
|
- private Guid? MyID;
|
|
|
- private string MyName = "";
|
|
|
- private string searchtext = "";
|
|
|
- private Guid selectedtype = CoreUtils.FullGuid;
|
|
|
+ public event PropertyChangedEventHandler? PropertyChanged;
|
|
|
|
|
|
- public TasksByStatusControl()
|
|
|
- {
|
|
|
- using (new EventSuppressor(Suppress.This))
|
|
|
- InitializeComponent();
|
|
|
- }
|
|
|
+ // Create the OnPropertyChanged method to raise the event
|
|
|
+ // The calling member's name will be used as the parameter.
|
|
|
+ protected void OnPropertyChanged([CallerMemberName] string? name = null)
|
|
|
+ {
|
|
|
+ PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
|
|
|
+ }
|
|
|
|
|
|
- public string SectionName => "Tasks By Status";
|
|
|
+ #endregion
|
|
|
|
|
|
- public DataModel DataModel(Selection selection)
|
|
|
- {
|
|
|
- var ids = SelectedModels().Select(x => Guid.Parse(x.ID)).ToArray();
|
|
|
- return new AutoDataModel<Kanban>(new Filter<Kanban>(x => x.ID).InList(ids));
|
|
|
- }
|
|
|
+ #region Setup
|
|
|
|
|
|
- private void ResizeColumns()
|
|
|
- {
|
|
|
- //if (!bResizeRequired)
|
|
|
- // return;
|
|
|
+ public void Setup()
|
|
|
+ {
|
|
|
+ var employeesTask = Task.Run(() => LoadEmployees());
|
|
|
+ var kanbanTypesTask = Task.Run(() => LoadKanbanTypes());
|
|
|
|
|
|
- using (var d = Dispatcher.DisableProcessing())
|
|
|
- {
|
|
|
- var CollapsedWidth = 50;
|
|
|
- var CollapsedColumns = 0;
|
|
|
- Array.ForEach(Kanban.Columns.ToArray(), x => { CollapsedColumns += x.IsExpanded ? 0 : 1; });
|
|
|
- if (Kanban.Columns.Count > 0 && CollapsedColumns != Kanban.Columns.Count)
|
|
|
- {
|
|
|
- var ColumnWidth = (Kanban.ActualWidth - CollapsedColumns * CollapsedWidth) / (Kanban.Columns.Count - CollapsedColumns) - 2;
|
|
|
- if (ColumnWidth != Kanban.ColumnWidth) Kanban.ColumnWidth = ColumnWidth;
|
|
|
- //bResizeRequired = false;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
+ SetupToolbar();
|
|
|
|
|
|
+ SetupColumns();
|
|
|
|
|
|
- private void TaskMenu_Opened(object sender, RoutedEventArgs e)
|
|
|
- {
|
|
|
- Host.PopulateMenu(this, sender as ContextMenu);
|
|
|
- }
|
|
|
+ employeesTask.Wait();
|
|
|
+ SetupEmployeeList();
|
|
|
|
|
|
- private void Kanban_SizeChanged(object sender, SizeChangedEventArgs e)
|
|
|
- {
|
|
|
- Kanban.ColumnWidth = Kanban.ActualWidth / Kanban.Columns.Count - 1.0F;
|
|
|
- }
|
|
|
+ kanbanTypesTask.Wait();
|
|
|
+ SetupKanbanTypesLookup(kanbanTypesTask.Result);
|
|
|
|
|
|
- private void Kanban_CardDragStart(object sender, KanbanDragStartEventArgs e)
|
|
|
- {
|
|
|
- var models = SelectedModels(e.SelectedCard.Content as TaskModel);
|
|
|
- if (models.Any(x => x.Locked))
|
|
|
- e.IsCancel = true;
|
|
|
- }
|
|
|
+ Mode = Host.KanbanSettings.StatusSettings.CompactView ? KanbanViewMode.Compact : KanbanViewMode.Full;
|
|
|
+ }
|
|
|
|
|
|
- private void Kanban_CardDragEnd(object sender, KanbanDragEndEventArgs e)
|
|
|
- {
|
|
|
- using (new WaitCursor())
|
|
|
- {
|
|
|
- var target = e.TargetColumn.Categories;
|
|
|
- var models = SelectedModels(e.SelectedCard.Content as TaskModel).Where(x => !Equals(x.Category, target)).ToArray();
|
|
|
- if (!models.Any())
|
|
|
- return;
|
|
|
- var kanbans = Host.LoadKanbans(models, new Columns<Kanban>(x => x.ID, x => x.Category));
|
|
|
- foreach (var kanban in kanbans)
|
|
|
- kanban.Category = target;
|
|
|
- new Client<Kanban>().Save(kanbans, string.Format("Task Status Updated to {0}", target), (o, err) => { });
|
|
|
- foreach (var model in models)
|
|
|
- {
|
|
|
- model.Checked = false;
|
|
|
- model.Category = target;
|
|
|
- }
|
|
|
+ private void SetupToolbar()
|
|
|
+ {
|
|
|
+ IncludeCompleted.Visibility = Security.IsAllowed<CanHideTaskCompletedColumn>() ? Visibility.Visible : Visibility.Collapsed;
|
|
|
+ IncludeCompleted.IsChecked = IncludeCompleted.Visibility == Visibility.Visible ? Host.KanbanSettings.StatusSettings.IncludeCompleted : true;
|
|
|
+ IncludeObserved.IsChecked = Host.KanbanSettings.StatusSettings.IncludeObserved;
|
|
|
+ ViewType.SelectedIndex = Host.KanbanSettings.StatusSettings.CompactView ? 1 : 0;
|
|
|
+ }
|
|
|
|
|
|
- FilterKanbans();
|
|
|
- }
|
|
|
- }
|
|
|
+ #endregion
|
|
|
|
|
|
- private void Search_KeyUp(object sender, KeyEventArgs e)
|
|
|
- {
|
|
|
- if (string.IsNullOrWhiteSpace(Search.Text) || e.Key == Key.Return)
|
|
|
- {
|
|
|
- searchtext = Search.Text;
|
|
|
- Refresh(true);
|
|
|
- }
|
|
|
- }
|
|
|
+ #region Columns
|
|
|
|
|
|
- private void TaskTypes_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
|
- {
|
|
|
+ private void SetupColumns()
|
|
|
+ {
|
|
|
+ Columns.SupressNotification = true;
|
|
|
|
|
|
- if (!IsReady || EventSuppressor.IsSet(Suppress.This))
|
|
|
- return;
|
|
|
- if (e.AddedItems.Count > 0)
|
|
|
- {
|
|
|
- var item = (KeyValuePair<Guid, string>)e.AddedItems[0];
|
|
|
- selectedtype = item.Key;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- selectedtype = CoreUtils.FullGuid;
|
|
|
- }
|
|
|
+ Columns.Clear();
|
|
|
|
|
|
- Host.KanbanSettings.StatusSettings.SelectedType = selectedtype;
|
|
|
- Host.SaveSettings();
|
|
|
- ReloadKanbans();
|
|
|
- }
|
|
|
+ Columns.Add(new TasksByStatusColumn("Open", "To Do"));
|
|
|
|
|
|
- private void IncludeCompleted_Checked(object sender, RoutedEventArgs e)
|
|
|
- {
|
|
|
- if (!IsReady)
|
|
|
- return;
|
|
|
- Host.KanbanSettings.StatusSettings.IncludeCompleted = IncludeCompleted.IsChecked.Value;
|
|
|
- Host.SaveSettings();
|
|
|
- SetupColumns();
|
|
|
- ReloadKanbans();
|
|
|
- }
|
|
|
+ Columns.Add(new TasksByStatusColumn("In Progress", "In Progress"));
|
|
|
|
|
|
- private void IncludeObserved_Checked(object sender, RoutedEventArgs e)
|
|
|
- {
|
|
|
- if (!IsReady)
|
|
|
- return;
|
|
|
- Host.KanbanSettings.StatusSettings.IncludeObserved = IncludeObserved.IsChecked.Value;
|
|
|
- Host.SaveSettings();
|
|
|
- ReloadKanbans();
|
|
|
- }
|
|
|
+ Columns.Add(new TasksByStatusColumn("Waiting", "Waiting for Others"));
|
|
|
|
|
|
- private void IncludeLocked_Checked(object sender, RoutedEventArgs e)
|
|
|
- {
|
|
|
- if (!IsReady)
|
|
|
- return;
|
|
|
- Host.KanbanSettings.StatusSettings.IncludeLocked = IncludeLocked.IsChecked.Value;
|
|
|
- Host.SaveSettings();
|
|
|
- ReloadKanbans();
|
|
|
- }
|
|
|
+ if (Host.KanbanSettings.StatusSettings.IncludeCompleted)
|
|
|
+ Columns.Add(new TasksByStatusColumn("Complete", "Completed"));
|
|
|
|
|
|
- private void ViewType_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
|
- {
|
|
|
- if (Kanban != null)
|
|
|
- Kanban.CardTemplate = ViewType.SelectedIndex > 0
|
|
|
- ? Resources["CompactKanban"] as DataTemplate
|
|
|
- : Resources["FullKanban"] as DataTemplate;
|
|
|
- if (!IsReady || EventSuppressor.IsSet(Suppress.This))
|
|
|
- return;
|
|
|
- Host.KanbanSettings.StatusSettings.CompactView = ViewType.SelectedIndex > 0;
|
|
|
- Host.SaveSettings();
|
|
|
+ Columns.SupressNotification = false;
|
|
|
+ }
|
|
|
|
|
|
- }
|
|
|
+ private TasksByStatusColumn? GetColumn(string category)
|
|
|
+ {
|
|
|
+ return Columns.FirstOrDefault(x => x.Category.Equals(category));
|
|
|
+ }
|
|
|
|
|
|
- private static bool UpdatingEmployees = false;
|
|
|
+ private void Column_ContextMenuOpening(object sender, ContextMenuEventArgs e)
|
|
|
+ {
|
|
|
+ if (sender is not FrameworkElement element || element.Tag is not TasksByStatusColumn column) return;
|
|
|
|
|
|
- private void Employees_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
|
- {
|
|
|
- if (UpdatingEmployees || EventSuppressor.IsSet(Suppress.This))
|
|
|
- return;
|
|
|
+ var menu = element.ContextMenu;
|
|
|
|
|
|
- if (e.AddedItems.Count == 0)
|
|
|
- {
|
|
|
- EmployeeID = Guid.Empty;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- var model = _employeelist[Employees.SelectedIndex];
|
|
|
- EmployeeID = model.ID;
|
|
|
- }
|
|
|
+ menu.Items.Clear();
|
|
|
|
|
|
- CheckedKanbans.Clear();
|
|
|
- if (IsReady)
|
|
|
- Refresh(true);
|
|
|
- }
|
|
|
+ menu.AddItem("New Task", null, CreateTask);
|
|
|
+ menu.AddItem($"Select all {column.Title} tasks", null, column, SelectAll);
|
|
|
+ menu.AddItem($"Deselect all {column.Title} tasks", null, column, DeselectAll);
|
|
|
+ }
|
|
|
|
|
|
- private void Export_Click(object sender, RoutedEventArgs e)
|
|
|
+ private void SelectColumn(TasksByStatusColumn column, bool selected)
|
|
|
+ {
|
|
|
+ SelectedTasks.Clear();
|
|
|
+ if (selected)
|
|
|
{
|
|
|
- var form = new DynamicExportForm(typeof(Kanban), _kanbans.Columns.Select(x => x.ColumnName));
|
|
|
- if (form.ShowDialog() != true)
|
|
|
- return;
|
|
|
- var export = new Client<Kanban>().Query(
|
|
|
- GetKanbanFilter(),
|
|
|
- new Columns<Kanban>(form.Fields),
|
|
|
- LookupFactory.DefineSort<Kanban>()
|
|
|
- );
|
|
|
-
|
|
|
- var employee = "Tasks for All Staff";
|
|
|
- if (EmployeeID != CoreUtils.FullGuid)
|
|
|
- {
|
|
|
- if (EmployeeID == Guid.Empty)
|
|
|
- {
|
|
|
- employee = "Unallocated Tasks";
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- var model = _employeelist.FirstOrDefault(x => x.ID.Equals(EmployeeID));
|
|
|
- employee = model == null ? "Tasks for (Unknown)" : "Tasks for " + (model.ID == MyID ? MyName : model.Name);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ExcelExporter.DoExport<Kanban>(
|
|
|
- export,
|
|
|
- string.Format(
|
|
|
- "{0} ({1:dd-MMM-yy})",
|
|
|
- employee,
|
|
|
- DateTime.Today
|
|
|
- )
|
|
|
- );
|
|
|
+ SelectedTasks.AddRange(column.Tasks);
|
|
|
+ foreach (var task in Tasks)
|
|
|
+ task.Checked = string.Equals(task.Category, column.Category) ? selected : !selected;
|
|
|
}
|
|
|
|
|
|
- #region ITaskControl Support
|
|
|
+ FilterKanbans();
|
|
|
+ }
|
|
|
|
|
|
- public bool IsReady { get; set; }
|
|
|
+ private void DeselectAll(TasksByStatusColumn column)
|
|
|
+ {
|
|
|
+ SelectColumn(column, false);
|
|
|
+ }
|
|
|
|
|
|
- public ITaskHost Host { get; set; }
|
|
|
+ private void SelectAll(TasksByStatusColumn column)
|
|
|
+ {
|
|
|
+ SelectColumn(column, true);
|
|
|
+ }
|
|
|
|
|
|
- public KanbanViewType KanbanViewType => KanbanViewType.Status;
|
|
|
+ #endregion
|
|
|
|
|
|
- public IEnumerable<TaskModel> SelectedModels(TaskModel sender = null)
|
|
|
- {
|
|
|
- var result = _models.Where(x => x.Checked).ToList();
|
|
|
- if (sender != null && !result.Contains(sender))
|
|
|
- result.Add(sender);
|
|
|
- return result;
|
|
|
- }
|
|
|
+ #region Kanban Types
|
|
|
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region Setup
|
|
|
+ private IEnumerable<KanbanType> LoadKanbanTypes()
|
|
|
+ {
|
|
|
+ return Client.Query(
|
|
|
+ new Filter<KanbanType>(x => x.Hidden).IsEqualTo(false),
|
|
|
+ new Columns<KanbanType>(x => x.ID, x => x.Description),
|
|
|
+ new SortOrder<KanbanType>(x => x.Description))
|
|
|
+ .ToObjects<KanbanType>();
|
|
|
+ }
|
|
|
|
|
|
- public void Setup()
|
|
|
+ private void SetupKanbanTypesLookup(IEnumerable<KanbanType> kanbanTypes)
|
|
|
+ {
|
|
|
+ if (ClientFactory.IsSupported<KanbanType>())
|
|
|
{
|
|
|
- using (new EventSuppressor(Suppress.This))
|
|
|
+ var tasktypes = new Dictionary<Guid, string>
|
|
|
+ {
|
|
|
+ { CoreUtils.FullGuid, "All Types" },
|
|
|
+ { Guid.Empty, "Unallocated Types" }
|
|
|
+ };
|
|
|
+ foreach(var type in kanbanTypes)
|
|
|
{
|
|
|
- SetupToolbar();
|
|
|
+ tasktypes.Add(type.ID, type.Description);
|
|
|
+ }
|
|
|
|
|
|
- SetupColumns();
|
|
|
+ TaskTypes.ItemsSource = tasktypes;
|
|
|
+ if (tasktypes.ContainsKey(Host.KanbanSettings.StatusSettings.SelectedType))
|
|
|
+ TaskTypes.SelectedValue = Host.KanbanSettings.StatusSettings.SelectedType;
|
|
|
+ else
|
|
|
+ TaskTypes.SelectedValue = CoreUtils.FullGuid;
|
|
|
|
|
|
- SetupData();
|
|
|
+ TaskTypesLabel.Visibility = Visibility.Visible;
|
|
|
+ TaskTypes.Visibility = Visibility.Visible;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ TaskTypesLabel.Visibility = Visibility.Collapsed;
|
|
|
+ TaskTypes.Visibility = Visibility.Collapsed;
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- SetupKanbanTypesLookup(false);
|
|
|
+ #endregion
|
|
|
|
|
|
- SetupMyEmployee();
|
|
|
+ #region Employees
|
|
|
|
|
|
- SetupEmployeeList();
|
|
|
- }
|
|
|
- }
|
|
|
+ private EmployeeModel SelectedEmployee;
|
|
|
|
|
|
- private void SetupMyEmployee()
|
|
|
+ private void LoadEmployees()
|
|
|
+ {
|
|
|
+ Employees.Clear();
|
|
|
+
|
|
|
+ var employeeFilter = Security.IsAllowed<CanViewOthersTasks>()
|
|
|
+ ? new Filter<Employee>(x => x.CanAllocateTasks).IsEqualTo(true)
|
|
|
+ .And(new Filter<Employee>(x => x.FinishDate).IsEqualTo(DateTime.MinValue)
|
|
|
+ .Or(x => x.FinishDate).IsGreaterThan(DateTime.Today))
|
|
|
+ : new Filter<Employee>(x => x.ID).IsEqualTo(App.EmployeeID);
|
|
|
+
|
|
|
+ var employees = Client.Query<Employee>(
|
|
|
+ employeeFilter,
|
|
|
+ new Columns<Employee>(x => x.ID)
|
|
|
+ .Add(x => x.Thumbnail.ID)
|
|
|
+ .Add(x => x.Name));
|
|
|
+
|
|
|
+ var anonymous = PRSDesktop.Resources.anonymous.AsBitmapImage();
|
|
|
+ anonymous.Freeze();
|
|
|
+ if (Security.IsAllowed<CanViewOthersTasks>())
|
|
|
{
|
|
|
- var row = _employees.Rows.FirstOrDefault(r => r.Get<Employee, Guid>(c => c.UserLink.ID) == ClientFactory.UserGuid);
|
|
|
- if (row != null)
|
|
|
- {
|
|
|
- MyID = row.Get<Employee, Guid>(c => c.ID);
|
|
|
- MyName = row.Get<Employee, string>(x => x.Name);
|
|
|
- }
|
|
|
+ var everyone = PRSDesktop.Resources.everyone.AsBitmapImage();
|
|
|
+ everyone.Freeze();
|
|
|
+ Employees.Add(new EmployeeModel(CoreUtils.FullGuid, "All Staff", Guid.Empty, everyone));
|
|
|
+ Employees.Add(new EmployeeModel(Guid.Empty, "Unallocated", Guid.Empty, null));
|
|
|
}
|
|
|
|
|
|
- private void SetupEmployeeList()
|
|
|
+ foreach (var employee in employees.ToObjects<Employee>())
|
|
|
{
|
|
|
- IEnumerable<CoreRow> active = null;
|
|
|
- var anonymous = PRSDesktop.Resources.anonymous.AsBitmapImage();
|
|
|
- if (Security.IsAllowed<CanViewOthersTasks>())
|
|
|
- {
|
|
|
- active = _employees.Rows.Where(r =>
|
|
|
- r.Get<Employee, bool>(x => x.CanAllocateTasks) && (r.Get<Employee, DateTime>(x => x.FinishDate).IsEmpty() ||
|
|
|
- r.Get<Employee, DateTime>(x => x.FinishDate) > DateTime.Today));
|
|
|
- _employeelist.Add(new EmployeeModel(CoreUtils.FullGuid, "All Staff", Guid.Empty, PRSDesktop.Resources.everyone.AsBitmapImage()));
|
|
|
- _employeelist.Add(new EmployeeModel(Guid.Empty, "Unallocated", Guid.Empty, null));
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- active = _employees.Rows.Where(r => r.Get<Employee, Guid>(c => c.UserLink.ID).Equals(ClientFactory.UserGuid));
|
|
|
- }
|
|
|
-
|
|
|
- EmployeeModel selected = null;
|
|
|
- foreach (var row in active)
|
|
|
- {
|
|
|
- var id = row.Get<Employee, Guid>(x => x.ID);
|
|
|
- var userid = row.Get<Employee, Guid>(x => x.UserLink.ID);
|
|
|
- var thumbnailid = row.Get<Employee, Guid>(x => x.Thumbnail.ID);
|
|
|
- var name = userid.Equals(ClientFactory.UserGuid) ? "My Tasks" : row.Get<Employee, string>(x => x.Name);
|
|
|
+ var name = employee.ID == App.EmployeeID ? "My Tasks" : employee.Name;
|
|
|
|
|
|
- var model = new EmployeeModel(id, name, thumbnailid, anonymous);
|
|
|
-
|
|
|
- if (userid.Equals(ClientFactory.UserGuid))
|
|
|
- {
|
|
|
- _employeelist.Insert(0, model);
|
|
|
- selected = model;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- _employeelist.Add(model);
|
|
|
- }
|
|
|
- }
|
|
|
+ var model = new EmployeeModel(employee.ID, name, employee.Thumbnail.ID, anonymous);
|
|
|
|
|
|
- if (Security.IsAllowed<CanViewOthersTasks>())
|
|
|
+ if (employee.ID == App.EmployeeID)
|
|
|
{
|
|
|
- EmployeeListColumn.Width = new GridLength(1.0F, GridUnitType.Auto);
|
|
|
- var thumbnails = active
|
|
|
- .Select(r => r.EntityLinkID<Employee, ImageDocumentLink>(x => x.Thumbnail) ?? Guid.Empty)
|
|
|
- .Where(x => x != Guid.Empty).ToArray();
|
|
|
- Employees.ItemsSource = _employeelist;
|
|
|
- Employees.SelectedItem = _employeelist.First();
|
|
|
- EmployeeID = _employeelist.First().ID;
|
|
|
- if (thumbnails.Any())
|
|
|
- new Client<Document>().Query(
|
|
|
- new Filter<Document>(x => x.ID).InList(thumbnails),
|
|
|
- new Columns<Document>(x => x.ID, x => x.Data),
|
|
|
- null,
|
|
|
- (data, error) =>
|
|
|
- {
|
|
|
- if (data != null)
|
|
|
- ProcessThumbnails(data);
|
|
|
- }
|
|
|
- );
|
|
|
+ Employees.Insert(0, model);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
- EmployeeListColumn.Width = new GridLength(0.0F, GridUnitType.Pixel);
|
|
|
- Employees.ItemsSource = _employeelist;
|
|
|
- Employees.SelectedItem = _employeelist.First();
|
|
|
- EmployeeID = _employeelist.First().ID;
|
|
|
+ Employees.Add(model);
|
|
|
}
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- private void ProcessThumbnails(CoreTable data)
|
|
|
+ private void SetupEmployeeList()
|
|
|
+ {
|
|
|
+ if (Security.IsAllowed<CanViewOthersTasks>())
|
|
|
{
|
|
|
- Dispatcher.Invoke(() =>
|
|
|
- {
|
|
|
- foreach (var row in data.Rows)
|
|
|
- {
|
|
|
- var id = row.Get<Document, Guid>(x => x.ID);
|
|
|
- var model = _employeelist.FirstOrDefault(x => x.ThumbnailID.Equals(id));
|
|
|
- if (model != null)
|
|
|
+ EmployeeListColumn.Width = new GridLength(1.0F, GridUnitType.Auto);
|
|
|
+ var thumbnails = Employees
|
|
|
+ .Select(e => e.ThumbnailID)
|
|
|
+ .Where(x => x != Guid.Empty).ToArray();
|
|
|
+ EmployeeList.ItemsSource = Employees;
|
|
|
+ SelectedEmployee = Employees.First();
|
|
|
+ EmployeeList.SelectedItem = SelectedEmployee;
|
|
|
+ if (thumbnails.Any())
|
|
|
+ new Client<Document>().Query(
|
|
|
+ new Filter<Document>(x => x.ID).InList(thumbnails),
|
|
|
+ new Columns<Document>(x => x.ID, x => x.Data),
|
|
|
+ null,
|
|
|
+ (data, error) =>
|
|
|
{
|
|
|
- model.Image = new BitmapImage();
|
|
|
- model.Image.LoadImage(row.Get<Document, byte[]>(x => x.Data));
|
|
|
+ if (data != null)
|
|
|
+ ProcessThumbnails(data);
|
|
|
}
|
|
|
- }
|
|
|
-
|
|
|
- UpdatingEmployees = true;
|
|
|
- Employees.ItemsSource = null;
|
|
|
- Employees.ItemsSource = _employeelist;
|
|
|
- Employees.SelectedItem = _employeelist.First();
|
|
|
- EmployeeID = _employeelist.First().ID;
|
|
|
- UpdatingEmployees = false;
|
|
|
- });
|
|
|
+ );
|
|
|
}
|
|
|
+ else
|
|
|
+ {
|
|
|
+ EmployeeListColumn.Width = new GridLength(0.0F, GridUnitType.Pixel);
|
|
|
+ EmployeeList.ItemsSource = Employees;
|
|
|
+ SelectedEmployee = Employees.First();
|
|
|
+ EmployeeList.SelectedItem = SelectedEmployee;
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- private void SetupKanbanTypesLookup(bool reload)
|
|
|
+ private bool _updatingEmployees = false;
|
|
|
+ private void ProcessThumbnails(CoreTable data)
|
|
|
+ {
|
|
|
+ Dispatcher.Invoke(() =>
|
|
|
{
|
|
|
- if (ClientFactory.IsSupported<KanbanType>())
|
|
|
+ foreach (var row in data.Rows)
|
|
|
{
|
|
|
-
|
|
|
- if (reload)
|
|
|
+ var id = row.Get<Document, Guid>(x => x.ID);
|
|
|
+ var model = Employees.FirstOrDefault(x => x.ThumbnailID.Equals(id));
|
|
|
+ if (model != null)
|
|
|
{
|
|
|
- _types = new Client<KanbanType>().Query(
|
|
|
- new Filter<KanbanType>(x => x.Hidden).IsEqualTo(false),
|
|
|
- new Columns<KanbanType>(x => x.ID, x => x.Description),
|
|
|
- new SortOrder<KanbanType>(x => x.Description)
|
|
|
- );
|
|
|
+ model.Image = new BitmapImage();
|
|
|
+ model.Image.LoadImage(row.Get<Document, byte[]>(x => x.Data));
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- var tasktypes = new Dictionary<Guid, string>
|
|
|
- {
|
|
|
- { CoreUtils.FullGuid, "All Types" },
|
|
|
- { Guid.Empty, "Unallocated Types" }
|
|
|
- };
|
|
|
- _types.IntoDictionary<KanbanType, Guid, string>(tasktypes, x => x.ID, row => row.Get<KanbanType, string>(x => x.Description));
|
|
|
+ _updatingEmployees = true;
|
|
|
+ EmployeeList.ItemsSource = null;
|
|
|
+ EmployeeList.ItemsSource = Employees;
|
|
|
+ SelectedEmployee = Employees.First();
|
|
|
+ EmployeeList.SelectedItem = SelectedEmployee;
|
|
|
+ _updatingEmployees = false;
|
|
|
+ });
|
|
|
+ }
|
|
|
|
|
|
- TaskTypes.ItemsSource = tasktypes;
|
|
|
- if (tasktypes.ContainsKey(Host.KanbanSettings.StatusSettings.SelectedType))
|
|
|
- TaskTypes.SelectedValue = Host.KanbanSettings.StatusSettings.SelectedType;
|
|
|
- else
|
|
|
- TaskTypes.SelectedValue = CoreUtils.FullGuid;
|
|
|
+ private void Employees_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
|
+ {
|
|
|
+ if (_updatingEmployees || EventSuppressor.IsSet(Suppress.This))
|
|
|
+ return;
|
|
|
|
|
|
- TaskTypesLabel.Visibility = Visibility.Visible;
|
|
|
- TaskTypes.Visibility = Visibility.Visible;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- TaskTypesLabel.Visibility = Visibility.Collapsed;
|
|
|
- TaskTypes.Visibility = Visibility.Collapsed;
|
|
|
- }
|
|
|
- }
|
|
|
+ SelectedEmployee = (EmployeeList.SelectedItem as EmployeeModel)!;
|
|
|
|
|
|
- private void SetupToolbar()
|
|
|
- {
|
|
|
- IncludeCompleted.Visibility = Security.IsAllowed<CanHideTaskCompletedColumn>() ? Visibility.Visible : Visibility.Collapsed;
|
|
|
- IncludeCompleted.IsChecked = IncludeCompleted.Visibility == Visibility.Visible ? Host.KanbanSettings.StatusSettings.IncludeCompleted : true;
|
|
|
- IncludeObserved.IsChecked = Host.KanbanSettings.StatusSettings.IncludeObserved;
|
|
|
- ViewType.SelectedIndex = Host.KanbanSettings.StatusSettings.CompactView ? 1 : 0;
|
|
|
- }
|
|
|
+ SelectedTasks.Clear();
|
|
|
+ if (IsReady)
|
|
|
+ Refresh();
|
|
|
+ }
|
|
|
|
|
|
- private void SetupColumns()
|
|
|
- {
|
|
|
- Kanban.Columns.Clear();
|
|
|
+ #endregion
|
|
|
|
|
|
- var indicatorColorPalette = new IndicatorColorPalette();
|
|
|
- indicatorColorPalette.Add(new ColorMapping { Key = "Red", Color = Colors.LightSalmon });
|
|
|
- indicatorColorPalette.Add(new ColorMapping { Key = "Orange", Color = Colors.Orange });
|
|
|
- indicatorColorPalette.Add(new ColorMapping { Key = "Yellow", Color = Colors.LightYellow });
|
|
|
- indicatorColorPalette.Add(new ColorMapping { Key = "Green", Color = Colors.LightGreen });
|
|
|
- Kanban.IndicatorColorPalette = indicatorColorPalette;
|
|
|
+ #region Kanbans
|
|
|
|
|
|
- Kanban.Columns.Add(new KanbanColumn
|
|
|
- {
|
|
|
- Categories = "Open",
|
|
|
- Title = "To Do"
|
|
|
- });
|
|
|
+ private List<TaskModel> AllTasks { get; set; } = new();
|
|
|
+ private IEnumerable<TaskModel> Tasks => Columns.SelectMany(x => x.Tasks);
|
|
|
|
|
|
- Kanban.Columns.Add(new KanbanColumn
|
|
|
- {
|
|
|
- Categories = "In Progress",
|
|
|
- Title = "In Progress"
|
|
|
- });
|
|
|
+ private readonly List<TaskModel> SelectedTasks = new();
|
|
|
|
|
|
- Kanban.Columns.Add(new KanbanColumn
|
|
|
+ private void CreateTask()
|
|
|
+ {
|
|
|
+ var result = Host.CreateKanban(
|
|
|
+ kanban =>
|
|
|
{
|
|
|
- Categories = "Waiting",
|
|
|
- Title = "Waiting for Others"
|
|
|
+ kanban.EmployeeLink.ID = SelectedEmployee.ID != CoreUtils.FullGuid ? SelectedEmployee.ID : App.EmployeeID;
|
|
|
+ kanban.ManagerLink.ID = App.EmployeeID;
|
|
|
+ kanban.ManagerLink.UserLink.ID = ClientFactory.UserGuid;
|
|
|
});
|
|
|
+ if (result != null)
|
|
|
+ Refresh();
|
|
|
+ }
|
|
|
|
|
|
- if (Host.KanbanSettings.StatusSettings.IncludeCompleted)
|
|
|
- Kanban.Columns.Add(new KanbanColumn
|
|
|
- {
|
|
|
- Categories = "Complete",
|
|
|
- Title = "Completed"
|
|
|
- });
|
|
|
- Kanban.InvalidateVisual();
|
|
|
+ private void DoEdit(TaskModel task)
|
|
|
+ {
|
|
|
+ var result = Host.EditReferences(new[] { task });
|
|
|
+ if (result)
|
|
|
+ {
|
|
|
+ Refresh();
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- foreach (var column in Kanban.Columns)
|
|
|
- {
|
|
|
- var menu = new ContextMenu();
|
|
|
- menu.Tag = column;
|
|
|
- var item = new MenuItem { Header = "New Task" };
|
|
|
- item.Click += CreateTask;
|
|
|
- menu.Items.Add(item);
|
|
|
- menu.Items.Add(new Separator());
|
|
|
- item = new MenuItem { Header = "Select All " + column.Title + " Tasks", Tag = column };
|
|
|
- item.Click += SelectAll_Click;
|
|
|
- menu.Items.Add(item);
|
|
|
- item = new MenuItem { Header = "Unselect All " + column.Title + " Tasks", Tag = column };
|
|
|
- item.Click += UnSelectAll_Click;
|
|
|
- menu.Items.Add(item);
|
|
|
- column.ContextMenu = menu;
|
|
|
- }
|
|
|
+ private void EditTask_Executed(object sender, ExecutedRoutedEventArgs e)
|
|
|
+ {
|
|
|
+ if (e.Parameter is not TaskModel model) return;
|
|
|
|
|
|
- Kanban.ColumnWidth = Kanban.ActualWidth / Kanban.Columns.Count - 1.0F;
|
|
|
- }
|
|
|
+ DoEdit(model);
|
|
|
+ }
|
|
|
|
|
|
- private void SetupData()
|
|
|
- {
|
|
|
- var query = new MultiQuery();
|
|
|
-
|
|
|
- query.Add(
|
|
|
- null,
|
|
|
- new Columns<Employee>(x => x.ID, x => x.Name, x => x.Thumbnail.ID, x => x.CanAllocateTasks, x => x.Email, x => x.Mobile,
|
|
|
- x => x.FinishDate, x => x.UserLink.ID),
|
|
|
- new SortOrder<Employee>(x => x.Name)
|
|
|
- );
|
|
|
-
|
|
|
- if (ClientFactory.IsSupported<KanbanType>())
|
|
|
- query.Add(
|
|
|
- new Filter<KanbanType>(x => x.Hidden).IsEqualTo(false),
|
|
|
- new Columns<KanbanType>(x => x.ID, x => x.Description),
|
|
|
- new SortOrder<KanbanType>(x => x.Description)
|
|
|
- );
|
|
|
+ private void OpenTaskMenu_Executed(object sender, ExecutedRoutedEventArgs e)
|
|
|
+ {
|
|
|
+ if (e.Parameter is not KanbanResources.OpenTaskMenuCommandArgs args) return;
|
|
|
|
|
|
- query.Query();
|
|
|
+ Host.PopulateMenu(this, args.Model, args.Menu);
|
|
|
+ }
|
|
|
|
|
|
- _employees = query.Get<Employee>();
|
|
|
- _types = ClientFactory.IsSupported<KanbanType>()
|
|
|
- ? query.Get<KanbanType>()
|
|
|
- : null;
|
|
|
+ private void SelectTask_Executed(object sender, ExecutedRoutedEventArgs e)
|
|
|
+ {
|
|
|
+ if (e.Parameter is not TaskModel model) return;
|
|
|
+
|
|
|
+ if (!SelectedTasks.Remove(model))
|
|
|
+ {
|
|
|
+ SelectedTasks.Add(model);
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- #endregion
|
|
|
+ private void CommandBinding_CanExecute(object sender, CanExecuteRoutedEventArgs e)
|
|
|
+ {
|
|
|
+ e.CanExecute = true;
|
|
|
+ }
|
|
|
|
|
|
- #region Refresh / Reload
|
|
|
+ private void ItemsControl_DragOver(object sender, DragEventArgs e)
|
|
|
+ {
|
|
|
+ if (sender is not FrameworkElement element || element.Tag is not TasksByStatusColumn column) return;
|
|
|
|
|
|
- private Filter<T> GetSearchFilter<T>(Expression<Func<T, object>> expression) where T : Entity, new()
|
|
|
+ e.Effects = DragDropEffects.None;
|
|
|
+ if (e.Data.GetDataPresent(typeof(TaskModel)))
|
|
|
{
|
|
|
- Filter<T> result = null;
|
|
|
- var comps = searchtext.Trim().Split(' ');
|
|
|
- foreach (var comp in comps)
|
|
|
- result = result == null ? new Filter<T>(expression).Contains(comp) : result.And(expression).Contains(comp);
|
|
|
- return result;
|
|
|
+ var model = e.Data.GetData(typeof(TaskModel)) as TaskModel;
|
|
|
+ if(model is not null && model.Category != column.Category && !SelectedTasks.Any(x => x.Locked))
|
|
|
+ {
|
|
|
+ e.Effects = DragDropEffects.Move;
|
|
|
+ }
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- private Filter<KanbanSubscriber> GetKanbanSubscriberFilter()
|
|
|
+ private void ChangeStatus(IEnumerable<TaskModel> tasks, string status)
|
|
|
+ {
|
|
|
+ var models = tasks
|
|
|
+ .Where(x => !x.Category.Equals(status))
|
|
|
+ .Where(x => !x.Locked)
|
|
|
+ .ToList();
|
|
|
+ if (!models.Any())
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if(status.Equals(Kanban.COMPLETE))
|
|
|
{
|
|
|
- var filter = new Filter<KanbanSubscriber>(x => x.Kanban.Closed).IsEqualTo(DateTime.MinValue);
|
|
|
+ if (MessageBox.Show($"Are you sure you want to complete the selected tasks?", "Confirm Completion",
|
|
|
+ MessageBoxButton.YesNo) != MessageBoxResult.Yes)
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var completed = DateTime.Now;
|
|
|
|
|
|
- if (Host.Job != null)
|
|
|
+ var kanbans = Host.LoadKanbans(tasks, new Columns<Kanban>(x => x.ID).Add(x => x.Category));
|
|
|
+ foreach (var kanban in kanbans)
|
|
|
+ {
|
|
|
+ kanban.Category = status;
|
|
|
+ }
|
|
|
+ if (status.Equals(Kanban.COMPLETE))
|
|
|
+ {
|
|
|
+ foreach (var kanban in kanbans)
|
|
|
{
|
|
|
- if (Host.Job.ID != Guid.Empty)
|
|
|
- filter = filter.And(x => x.Kanban.JobLink.ID).IsEqualTo(Host.Job.ID);
|
|
|
- else
|
|
|
- filter = filter.And(x => x.Kanban.JobLink.ID).None();
|
|
|
+ kanban.Completed = completed;
|
|
|
}
|
|
|
+ }
|
|
|
+ Client.Save(kanbans, $"Task Status Updated to {status}", (o, err) =>
|
|
|
+ {
|
|
|
+ if (err is not null)
|
|
|
+ {
|
|
|
+ CoreUtils.LogException("", err);
|
|
|
+ }
|
|
|
+ });
|
|
|
|
|
|
- // All Tasks (EmployeeID.HasValue == false) or Unallocated (EmployeeID = Guid.Empty) are retrieved directly from the Kanban Table
|
|
|
- // so if we are here, we can assume that we are pulling subscriber data
|
|
|
- var empfilter = new Filter<KanbanSubscriber>(x => x.Employee.ID).IsEqualTo(EmployeeID);
|
|
|
- filter.Ands.Add(empfilter);
|
|
|
+ foreach (var model in models)
|
|
|
+ {
|
|
|
+ model.Checked = false;
|
|
|
+ model.Category = status;
|
|
|
+ }
|
|
|
+ if (status.Equals(Kanban.COMPLETE))
|
|
|
+ {
|
|
|
+ foreach (var model in models)
|
|
|
+ {
|
|
|
+ model.CompletedDate = completed;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ FilterKanbans();
|
|
|
+ }
|
|
|
|
|
|
- if (EmployeeID != MyID)
|
|
|
- filter = filter.And(x => x.Kanban.Private).IsEqualTo(false);
|
|
|
+ private void ItemsControl_Drop(object sender, DragEventArgs e)
|
|
|
+ {
|
|
|
+ if (sender is not FrameworkElement element || element.Tag is not TasksByStatusColumn column) return;
|
|
|
|
|
|
- //if (!includeobserved)
|
|
|
- // filter = filter.And(new Filter<KanbanSubscriber>(x => x.Assignee).IsEqualTo(true).Or(x => x.Manager).IsEqualTo(true));
|
|
|
+ if (e.Data.GetDataPresent(typeof(TaskModel)))
|
|
|
+ {
|
|
|
+ ChangeStatus(SelectedModels(e.Data.GetData(typeof(TaskModel)) as TaskModel), column.Category);
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- //if (!includecompleted)
|
|
|
- // filter = filter.And(x => x.Kanban.Completed).IsEqualTo(DateTime.MinValue);
|
|
|
+ #endregion
|
|
|
|
|
|
- //if (selectedtype != CoreUtils.FullGuid)
|
|
|
- // filter = filter.And(x => x.Kanban.Type.ID).IsEqualTo(selectedtype);
|
|
|
+ #region Filters
|
|
|
|
|
|
- if (!string.IsNullOrWhiteSpace(searchtext))
|
|
|
- {
|
|
|
- var search = GetSearchFilter<KanbanSubscriber>(x => x.Kanban.JobLink.Name);
|
|
|
- search.Ors.Add(GetSearchFilter<KanbanSubscriber>(x => x.Kanban.JobLink.JobNumber));
|
|
|
- search.Ors.Add(GetSearchFilter<KanbanSubscriber>(x => x.Kanban.Summary));
|
|
|
- search.Ors.Add(GetSearchFilter<KanbanSubscriber>(x => x.Kanban.Title));
|
|
|
- search.Ors.Add(GetSearchFilter<KanbanSubscriber>(x => x.Kanban.ManagerLink.Name));
|
|
|
- search.Ors.Add(GetSearchFilter<KanbanSubscriber>(x => x.Kanban.EmployeeLink.Name));
|
|
|
+ private Guid JobFilterID = Guid.Empty;
|
|
|
+ private string SearchText = "";
|
|
|
+ private Guid SelectedType = CoreUtils.FullGuid;
|
|
|
|
|
|
- if (int.TryParse(searchtext.Trim(), out var tasknumber))
|
|
|
- search.Ors.Add(new Filter<KanbanSubscriber>(x => x.Kanban.Number).IsEqualTo(tasknumber));
|
|
|
+ private static Filter<T> GetSearchFilter<T>(Expression<Func<T, object?>> expression, string searchText) where T : Entity, new()
|
|
|
+ {
|
|
|
+ Filter<T>? result = null;
|
|
|
+ var comps = searchText.Trim().Split(' ');
|
|
|
+ foreach (var comp in comps)
|
|
|
+ result = result == null ? new Filter<T>(expression).Contains(comp) : result.And(expression).Contains(comp);
|
|
|
+ return result ?? new Filter<T>().All();
|
|
|
+ }
|
|
|
|
|
|
- filter.Ands.Add(search);
|
|
|
- }
|
|
|
+ private Filter<KanbanSubscriber> GetKanbanSubscriberFilter()
|
|
|
+ {
|
|
|
+ var filter = new Filter<KanbanSubscriber>(x => x.Kanban.Closed).IsEqualTo(DateTime.MinValue);
|
|
|
|
|
|
- return filter;
|
|
|
+ if (Host.Job != null)
|
|
|
+ {
|
|
|
+ if (Host.Job.ID != Guid.Empty)
|
|
|
+ filter = filter.And(x => x.Kanban.JobLink.ID).IsEqualTo(Host.Job.ID);
|
|
|
+ else
|
|
|
+ filter = filter.And(x => x.Kanban.JobLink.ID).None();
|
|
|
}
|
|
|
|
|
|
- private Filter<Kanban> GetKanbanFilter()
|
|
|
+ // All Tasks (EmployeeID.HasValue == false) or Unallocated (EmployeeID = Guid.Empty) are retrieved directly from the Kanban Table
|
|
|
+ // so if we are here, we can assume that we are pulling subscriber data
|
|
|
+ var empfilter = new Filter<KanbanSubscriber>(x => x.Employee.ID).IsEqualTo(SelectedEmployee.ID);
|
|
|
+ filter.Ands.Add(empfilter);
|
|
|
+
|
|
|
+ if (SelectedEmployee.ID != App.EmployeeID)
|
|
|
+ filter = filter.And(x => x.Kanban.Private).IsEqualTo(false);
|
|
|
+
|
|
|
+ return filter;
|
|
|
+ }
|
|
|
+
|
|
|
+ private Filter<Kanban> GetKanbanFilter()
|
|
|
+ {
|
|
|
+ var filter = new Filter<Kanban>(x => x.Closed).IsEqualTo(DateTime.MinValue);
|
|
|
+
|
|
|
+ if (Host.Job != null)
|
|
|
{
|
|
|
- var filter = new Filter<Kanban>(x => x.Closed).IsEqualTo(DateTime.MinValue);
|
|
|
+ if (Host.Job.ID != Guid.Empty)
|
|
|
+ filter = filter.And(x => x.JobLink.ID).IsEqualTo(Host.Job.ID);
|
|
|
+ else
|
|
|
+ filter = filter.And(x => x.JobLink.ID).None();
|
|
|
+ }
|
|
|
|
|
|
- if (Host.Job != null)
|
|
|
+ if (SelectedEmployee.ID != CoreUtils.FullGuid)
|
|
|
+ {
|
|
|
+ if (SelectedEmployee.ID != Guid.Empty)
|
|
|
{
|
|
|
- if (Host.Job.ID != Guid.Empty)
|
|
|
- filter = filter.And(x => x.JobLink.ID).IsEqualTo(Host.Job.ID);
|
|
|
- else
|
|
|
- filter = filter.And(x => x.JobLink.ID).None();
|
|
|
+ var empfilter = new Filter<Kanban>(x => x.EmployeeLink.ID).IsEqualTo(SelectedEmployee.ID)
|
|
|
+ .Or(x => x.ManagerLink.ID).IsEqualTo(SelectedEmployee.ID);
|
|
|
+ filter.Ands.Add(empfilter);
|
|
|
}
|
|
|
-
|
|
|
- if (EmployeeID != CoreUtils.FullGuid)
|
|
|
+ else
|
|
|
{
|
|
|
- if (EmployeeID != Guid.Empty)
|
|
|
- {
|
|
|
- var empfilter = new Filter<Kanban>(x => x.EmployeeLink.ID).IsEqualTo(EmployeeID).Or(x => x.ManagerLink.ID).IsEqualTo(EmployeeID);
|
|
|
- filter.Ands.Add(empfilter);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- filter = filter.And(x => x.EmployeeLink.ID).IsEqualTo(EmployeeID);
|
|
|
- }
|
|
|
+ filter = filter.And(x => x.EmployeeLink.ID).IsEqualTo(SelectedEmployee.ID);
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- if (EmployeeID != MyID)
|
|
|
- filter = filter.And(x => x.Private).IsEqualTo(false);
|
|
|
+ if (SelectedEmployee.ID != App.EmployeeID)
|
|
|
+ filter = filter.And(x => x.Private).IsEqualTo(false);
|
|
|
|
|
|
- //if (!includecompleted)
|
|
|
- // filter = filter.And(x => x.Completed).IsEqualTo(DateTime.MinValue);
|
|
|
+ return filter;
|
|
|
+ }
|
|
|
|
|
|
- //if (selectedtype != CoreUtils.FullGuid)
|
|
|
- // filter = filter.And(x => x.Type.ID).IsEqualTo(selectedtype);
|
|
|
+ private void TaskTypesLabel_OnClick(object sender, RoutedEventArgs e)
|
|
|
+ {
|
|
|
+ var list = new MasterList(typeof(KanbanType));
|
|
|
+ list.ShowDialog();
|
|
|
+ SetupKanbanTypesLookup(LoadKanbanTypes());
|
|
|
+ }
|
|
|
|
|
|
- return filter;
|
|
|
+ private void TaskTypes_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
|
+ {
|
|
|
+ if (!IsReady || EventSuppressor.IsSet(Suppress.This))
|
|
|
+ return;
|
|
|
+ if (e.AddedItems.Count > 0)
|
|
|
+ {
|
|
|
+ var item = (KeyValuePair<Guid, string>)e.AddedItems[0];
|
|
|
+ SelectedType = item.Key;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ SelectedType = CoreUtils.FullGuid;
|
|
|
}
|
|
|
|
|
|
- public void Refresh(bool resetselection)
|
|
|
+ Host.KanbanSettings.StatusSettings.SelectedType = SelectedType;
|
|
|
+ Host.SaveSettings();
|
|
|
+ FilterKanbans();
|
|
|
+ }
|
|
|
+
|
|
|
+ private void JobFilterBtn_OnClick(object sender, RoutedEventArgs e)
|
|
|
+ {
|
|
|
+ if (JobFilterID != Guid.Empty)
|
|
|
{
|
|
|
- Application.Current.Dispatcher.Invoke(() => { Mouse.OverrideCursor = Cursors.Wait; });
|
|
|
+ JobFilterBtn.Content = "Filter Job";
|
|
|
+ JobFilterID = Guid.Empty;
|
|
|
+ FilterKanbans();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var window = new ThemableWindow();
|
|
|
+ var grid = new JobGrid();
|
|
|
+ grid.Reconfigure(options =>
|
|
|
+ {
|
|
|
+ options.Remove(DynamicGridOption.EditRows);
|
|
|
+ options.Remove(DynamicGridOption.DeleteRows);
|
|
|
+ options.Remove(DynamicGridOption.AddRows);
|
|
|
+ options.Remove(DynamicGridOption.MultiSelect);
|
|
|
+ options.Remove(DynamicGridOption.ExportData);
|
|
|
+ options.Remove(DynamicGridOption.ImportData);
|
|
|
+ });
|
|
|
+ grid.OnSelectItem += (object sender, DynamicGridSelectionEventArgs e) =>
|
|
|
+ {
|
|
|
+ if (grid.SelectedRows.Count() == 0)
|
|
|
+ return;
|
|
|
|
|
|
- if (EmployeeID != CoreUtils.FullGuid && EmployeeID != Guid.Empty)
|
|
|
- {
|
|
|
- _kanbans = new Client<KanbanSubscriber>().Query(
|
|
|
- GetKanbanSubscriberFilter(),
|
|
|
- new Columns<KanbanSubscriber>
|
|
|
- (
|
|
|
- x => x.Kanban.ID,
|
|
|
- x => x.Kanban.DueDate,
|
|
|
- x => x.Kanban.Completed,
|
|
|
- //x => x.Kanban.Description,
|
|
|
- x => x.Kanban.Summary,
|
|
|
- x => x.Kanban.Category,
|
|
|
- x => x.Kanban.EmployeeLink.ID,
|
|
|
- x => x.Kanban.ManagerLink.ID,
|
|
|
- x => x.Kanban.Notes,
|
|
|
- x => x.Kanban.Title,
|
|
|
- x => x.Kanban.JobLink.ID,
|
|
|
- x => x.Kanban.JobLink.JobNumber,
|
|
|
- x => x.Kanban.JobLink.Name,
|
|
|
- x => x.Kanban.Type.ID,
|
|
|
- x => x.Kanban.Type.Code,
|
|
|
- x => x.Kanban.Number,
|
|
|
- x => x.Kanban.Attachments,
|
|
|
- x => x.Kanban.Locked
|
|
|
- ),
|
|
|
- new SortOrder<KanbanSubscriber>(x => x.Kanban.DueDate) { Direction = SortDirection.Ascending }
|
|
|
- );
|
|
|
- foreach (var column in _kanbans.Columns)
|
|
|
- column.ColumnName = column.ColumnName.Replace("Kanban.", "");
|
|
|
- }
|
|
|
else
|
|
|
{
|
|
|
- _kanbans = new Client<Kanban>().Query(
|
|
|
- GetKanbanFilter(),
|
|
|
- new Columns<Kanban>
|
|
|
- (
|
|
|
- x => x.ID,
|
|
|
- x => x.DueDate,
|
|
|
- x => x.Completed,
|
|
|
- //x => x.Description,
|
|
|
- x => x.Summary,
|
|
|
- x => x.Category,
|
|
|
- x => x.EmployeeLink.ID,
|
|
|
- x => x.ManagerLink.ID,
|
|
|
- x => x.Notes,
|
|
|
- x => x.Title,
|
|
|
- x => x.JobLink.ID,
|
|
|
- x => x.JobLink.JobNumber,
|
|
|
- x => x.JobLink.Name,
|
|
|
- x => x.Type.ID,
|
|
|
- x => x.Type.Code,
|
|
|
- x => x.Number,
|
|
|
- x => x.Attachments,
|
|
|
- x => x.Locked
|
|
|
- ),
|
|
|
- new SortOrder<Kanban>(x => x.DueDate) { Direction = SortDirection.Ascending }
|
|
|
- );
|
|
|
+ var item = grid.SelectedRows[0];
|
|
|
+ AddJobFilter(item);
|
|
|
+ window.Close();
|
|
|
}
|
|
|
+ };
|
|
|
+ grid.Refresh(true, true);
|
|
|
+ window.Content = grid;
|
|
|
+ window.ShowDialog();
|
|
|
+ }
|
|
|
+ private void AddJobFilter(CoreRow item)
|
|
|
+ {
|
|
|
+ JobFilterID = item.Get<Job, Guid>(x => x.ID);
|
|
|
+ JobFilterBtn.Content = item.Get<Job, string>(x => x.JobNumber) + " (click to cancel)";
|
|
|
+ FilterKanbans();
|
|
|
+ }
|
|
|
|
|
|
- ReloadKanbans();
|
|
|
-
|
|
|
- Application.Current.Dispatcher.Invoke(() => { Mouse.OverrideCursor = null; });
|
|
|
- }
|
|
|
+ private void IncludeCompleted_Checked(object sender, RoutedEventArgs e)
|
|
|
+ {
|
|
|
+ if (!IsReady)
|
|
|
+ return;
|
|
|
+ Host.KanbanSettings.StatusSettings.IncludeCompleted = IncludeCompleted.IsChecked ?? false;
|
|
|
+ Host.SaveSettings();
|
|
|
+ SetupColumns();
|
|
|
+ FilterKanbans();
|
|
|
+ }
|
|
|
|
|
|
- private void ReloadKanbans()
|
|
|
- {
|
|
|
- //SetupColumns();
|
|
|
- //ResizeColumns();
|
|
|
+ private void IncludeObserved_Checked(object sender, RoutedEventArgs e)
|
|
|
+ {
|
|
|
+ if (!IsReady)
|
|
|
+ return;
|
|
|
+ Host.KanbanSettings.StatusSettings.IncludeObserved = IncludeObserved.IsChecked ?? false;
|
|
|
+ Host.SaveSettings();
|
|
|
+ FilterKanbans();
|
|
|
+ }
|
|
|
|
|
|
- _models = new ObservableCollection<TaskModel>();
|
|
|
+ private void IncludeLocked_Checked(object sender, RoutedEventArgs e)
|
|
|
+ {
|
|
|
+ if (!IsReady)
|
|
|
+ return;
|
|
|
+ Host.KanbanSettings.StatusSettings.IncludeLocked = IncludeLocked.IsChecked ?? false;
|
|
|
+ Host.SaveSettings();
|
|
|
+ FilterKanbans();
|
|
|
+ }
|
|
|
|
|
|
- foreach (var row in _kanbans.Rows)
|
|
|
- try
|
|
|
- {
|
|
|
- var empid = row.Get<IKanban, Guid>(e => e.EmployeeLink.ID);
|
|
|
- var mgrid = row.EntityLinkID<IKanban, EmployeeLink>(x => x.ManagerLink) ?? Guid.Empty;
|
|
|
- var completed = row.Get<IKanban, DateTime>(e => e.Completed);
|
|
|
- var locked = row.Get<IKanban, bool>(e => e.Locked);
|
|
|
- var type = row.Get<IKanban, Guid>(e => e.Type.ID);
|
|
|
- var category = row.Get<IKanban, string>(x => x.Category);
|
|
|
- if (string.IsNullOrWhiteSpace(category))
|
|
|
- category = "Open";
|
|
|
-
|
|
|
-
|
|
|
- var bLockedOK = Host.KanbanSettings.StatusSettings.IncludeLocked || locked == false;
|
|
|
- var bObserveOK = EmployeeID == CoreUtils.FullGuid || Host.KanbanSettings.StatusSettings.IncludeObserved || empid == EmployeeID || mgrid == EmployeeID;
|
|
|
- var bCompleteOK = Host.KanbanSettings.StatusSettings.IncludeCompleted || completed.IsEmpty();
|
|
|
- var bTypeOK = selectedtype == CoreUtils.FullGuid || type == selectedtype;
|
|
|
- if (bLockedOK && bCompleteOK && bObserveOK && bTypeOK)
|
|
|
- {
|
|
|
- var model = new TaskModel();
|
|
|
- var EmployeeEntry = _employeelist.Where(x => x.ID.Equals(empid)).FirstOrDefault();
|
|
|
- var empimg = EmployeeEntry?.Image;
|
|
|
-
|
|
|
- var ManagerEntry = _employeelist.Where(x => x.ID.Equals(mgrid)).FirstOrDefault();
|
|
|
-
|
|
|
- //var description = row.Get<IKanban, String>(x => x.Summary);
|
|
|
- //if (String.IsNullOrWhiteSpace(description))
|
|
|
- // description = String.Join("\r\n", row.Get<IKanban, String[]>(x => x.Notes)).Split(new String[] { "===============" }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();
|
|
|
- //if (String.IsNullOrWhiteSpace(description))
|
|
|
- // description = CoreUtils.StripHTML(row.Get<IKanban, String>(x => x.Description));
|
|
|
- //if (String.IsNullOrWhiteSpace(description))
|
|
|
- // description = "";
|
|
|
- var job = row.Get<IKanban, string>(x => x.JobLink.JobNumber);
|
|
|
-
|
|
|
- model.Title = row.Get<IKanban, string>(x => x.Title);
|
|
|
- model.ID = row.Get<IKanban, Guid>(x => x.ID).ToString();
|
|
|
- model.Description = row.Get<IKanban, string>(x => x.Summary) ?? "";
|
|
|
- model.Category = category;
|
|
|
- var color = EmployeeID == Guid.Empty || empid == EmployeeID || EmployeeID == CoreUtils.FullGuid
|
|
|
- ? TaskModel.KanbanColor(
|
|
|
- row.Get<IKanban, DateTime>(x => x.DueDate),
|
|
|
- row.Get<IKanban, DateTime>(x => x.Completed))
|
|
|
- : mgrid == EmployeeID
|
|
|
- ? Color.Silver
|
|
|
- : Color.Plum;
|
|
|
- if (row.Get<IKanban, bool>(x => x.Locked))
|
|
|
- color = color.MixColors(0.5F, Color.White);
|
|
|
- model.ColorKey = ImageUtils.ColorToString(color);
|
|
|
- model.Image = empimg;
|
|
|
- model.ImageURL = null;
|
|
|
- model.Attachments = row.Get<IKanban, int>(x => x.Attachments) > 0; // ? _attachimg : null;
|
|
|
- model.DueDate = row.Get<IKanban, DateTime>(x => x.DueDate);
|
|
|
- model.CompletedDate = row.Get<IKanban, DateTime>(x => x.Completed);
|
|
|
- model.Locked = row.Get<IKanban, bool>(x => x.Locked); // ? _lockimg : null;
|
|
|
-
|
|
|
- var notes = new List<List<string>> { new() };
|
|
|
- if ((row.Get<IKanban, string[]>(x => x.Notes) != null))
|
|
|
- {
|
|
|
+ private void Search_KeyUp(object sender, KeyEventArgs e)
|
|
|
+ {
|
|
|
+ if (string.IsNullOrWhiteSpace(Search.Text) || e.Key == Key.Return)
|
|
|
+ {
|
|
|
+ SearchText = Search.Text;
|
|
|
+ FilterKanbans();
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
+ #endregion
|
|
|
|
|
|
- foreach (var line in row.Get<IKanban, string[]>(x => x.Notes))
|
|
|
- {
|
|
|
- if (line == "===================================")
|
|
|
- {
|
|
|
- notes.Add(new());
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- notes.Last().Add(line);
|
|
|
- }
|
|
|
- }
|
|
|
- model.Notes = string.Join("\n===================================\n", notes.Reverse<List<string>>().Select(x => string.Join('\n', x)));
|
|
|
- }
|
|
|
+ #region Refresh
|
|
|
|
|
|
- model.EmployeeID = empid;
|
|
|
- model.ManagerID = mgrid;
|
|
|
+ private static Columns<Kanban> GetKanbanColumns()
|
|
|
+ {
|
|
|
+ return new Columns<Kanban>(
|
|
|
+ x => x.ID,
|
|
|
+ x => x.DueDate,
|
|
|
+ x => x.Completed,
|
|
|
+ x => x.Summary,
|
|
|
+ x => x.Category,
|
|
|
+ x => x.EmployeeLink.ID,
|
|
|
+ x => x.ManagerLink.ID,
|
|
|
+ x => x.Notes,
|
|
|
+ x => x.Title,
|
|
|
+ x => x.JobLink.ID,
|
|
|
+ x => x.JobLink.JobNumber,
|
|
|
+ x => x.JobLink.Name,
|
|
|
+ x => x.Type.ID,
|
|
|
+ x => x.Type.Code,
|
|
|
+ x => x.Number,
|
|
|
+ x => x.Attachments,
|
|
|
+ x => x.EstimatedTime,
|
|
|
+ x => x.Locked);
|
|
|
+ }
|
|
|
|
|
|
- var sEmp = "";
|
|
|
- if (empid != EmployeeID)
|
|
|
- {
|
|
|
- if (!Entity.IsEntityLinkValid<IKanban, EmployeeLink>(x => x.EmployeeLink, row))
|
|
|
- {
|
|
|
- sEmp = "Unallocated";
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- var tuple = _employeelist.FirstOrDefault(x => x.ID.Equals(empid));
|
|
|
- sEmp = tuple != null ? tuple.ID == MyID ? MyName : tuple.Name : "";
|
|
|
- }
|
|
|
- }
|
|
|
+ public void Refresh()
|
|
|
+ {
|
|
|
+ using var cursor = new WaitCursor();
|
|
|
|
|
|
- var sMgr = "";
|
|
|
- if (mgrid != EmployeeID)
|
|
|
- if (mgrid != Guid.Empty)
|
|
|
- {
|
|
|
- var tuple = _employeelist.FirstOrDefault(x => x.ID.Equals(mgrid));
|
|
|
- sMgr = tuple != null ? tuple.ID == MyID ? MyName : tuple.Name : "";
|
|
|
- }
|
|
|
+ IEnumerable<Kanban> kanbans;
|
|
|
+ if (SelectedEmployee.ID != CoreUtils.FullGuid && SelectedEmployee.ID != Guid.Empty)
|
|
|
+ {
|
|
|
+ kanbans = Client.Query(
|
|
|
+ new Filter<Kanban>(x => x.ID).InQuery(GetKanbanSubscriberFilter(), x => x.Kanban.ID),
|
|
|
+ GetKanbanColumns().Cast<Kanban>(),
|
|
|
+ new SortOrder<Kanban>(x => x.DueDate) { Direction = SortDirection.Ascending }
|
|
|
+ ).ToObjects<Kanban>();
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ kanbans = new Client<Kanban>().Query(
|
|
|
+ GetKanbanFilter(),
|
|
|
+ GetKanbanColumns().Cast<Kanban>(),
|
|
|
+ new SortOrder<Kanban>(x => x.DueDate) { Direction = SortDirection.Ascending }
|
|
|
+ ).ToObjects<Kanban>();
|
|
|
+ }
|
|
|
|
|
|
- if (!string.IsNullOrEmpty(sEmp))
|
|
|
+ AllTasks = CreateModels(kanbans).ToList();
|
|
|
+ FilterKanbans();
|
|
|
+ }
|
|
|
+ private IEnumerable<TaskModel> CreateModels(IEnumerable<Kanban> kanbans)
|
|
|
+ {
|
|
|
+ foreach(var kanban in kanbans)
|
|
|
+ {
|
|
|
+ TaskModel? model = null;
|
|
|
+ try
|
|
|
+ {
|
|
|
+ model = new TaskModel();
|
|
|
+
|
|
|
+ var employee = Employees.FirstOrDefault(x => x.ID == kanban.EmployeeLink.ID);
|
|
|
+ var manager = Employees.FirstOrDefault(x => x.ID == kanban.ManagerLink.ID);
|
|
|
+
|
|
|
+ model.Title = kanban.Title;
|
|
|
+ model.ID = kanban.ID;
|
|
|
+ model.Description = kanban.Summary ?? "";
|
|
|
+ model.Category = kanban.Category;
|
|
|
+
|
|
|
+ var colour = SelectedEmployee.ID == Guid.Empty
|
|
|
+ || SelectedEmployee.ID == CoreUtils.FullGuid
|
|
|
+ || kanban.EmployeeLink.ID == SelectedEmployee.ID
|
|
|
+ ? TaskModel.KanbanColor(kanban.DueDate, kanban.Completed)
|
|
|
+ : (kanban.ManagerLink.ID == SelectedEmployee.ID
|
|
|
+ ? Color.Silver
|
|
|
+ : Color.Plum);
|
|
|
+ if (kanban.Locked)
|
|
|
+ {
|
|
|
+ colour = colour.MixColors(0.5F, Color.White);
|
|
|
+ }
|
|
|
+ model.Color = System.Windows.Media.Color.FromArgb(colour.A, colour.R, colour.G, colour.B);
|
|
|
+ model.Image = employee?.Image;
|
|
|
+ model.Attachments = kanban.Attachments > 0;
|
|
|
+ model.DueDate = kanban.DueDate;
|
|
|
+ model.CompletedDate = kanban.Completed;
|
|
|
+ model.Locked = kanban.Locked;
|
|
|
+ model.EstimatedTime = kanban.EstimatedTime;
|
|
|
+
|
|
|
+ var notes = new List<List<string>> { new() };
|
|
|
+ if (kanban.Notes is not null)
|
|
|
+ {
|
|
|
+ foreach (var line in kanban.Notes)
|
|
|
+ {
|
|
|
+ if (line.Equals("==================================="))
|
|
|
{
|
|
|
- if (!string.IsNullOrWhiteSpace(sMgr) && !string.Equals(sMgr, sEmp))
|
|
|
- model.AssignedTo = string.Format("Assigned to {0} by {1}", sEmp, sMgr);
|
|
|
- else
|
|
|
- model.AssignedTo = string.Format("Assigned to {0} ", sEmp);
|
|
|
+ notes.Add(new());
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
- if (!string.IsNullOrWhiteSpace(sMgr))
|
|
|
- model.AssignedTo = string.Format("Allocated by {0} ", sMgr);
|
|
|
+ notes.Last().Add(line);
|
|
|
}
|
|
|
+ }
|
|
|
+ model.Notes = string.Join(
|
|
|
+ "\n===================================\n",
|
|
|
+ notes.Reverse<List<string>>().Select(x => string.Join('\n', x)));
|
|
|
+ }
|
|
|
|
|
|
- //model.AssignedTo = String.Format("M: {0} / E: {1}", sMgr, sEmp);
|
|
|
- model.JobID = row.Get<IKanban, Guid>(x => x.JobLink.ID);
|
|
|
- model.JobNumber = row.Get<IKanban, string>(x => x.JobLink.JobNumber);
|
|
|
- if (string.IsNullOrWhiteSpace(model.JobNumber))
|
|
|
- model.JobNumber = "";
|
|
|
- model.JobName = row.Get<IKanban, string>(x => x.JobLink.Name);
|
|
|
- model.Checked = CheckedKanbans.Contains(row.Get<IKanban, Guid>(x => x.ID).ToString());
|
|
|
- model.Type = new KanbanType
|
|
|
- {
|
|
|
- ID = row.Get<IKanban, Guid>(x => x.Type.ID),
|
|
|
- Code = row.Get<IKanban, string>(x => x.Type.Code)
|
|
|
- };
|
|
|
- model.Number = row.Get<IKanban, int>(x => x.Number);
|
|
|
+ model.EmployeeID = kanban.EmployeeLink.ID;
|
|
|
+ model.ManagerID = kanban.ManagerLink.ID;
|
|
|
|
|
|
- _models.Add(model);
|
|
|
+ var employeeString = "";
|
|
|
+ if (kanban.EmployeeLink.ID != SelectedEmployee.ID)
|
|
|
+ {
|
|
|
+ if (kanban.EmployeeLink.ID == Guid.Empty)
|
|
|
+ {
|
|
|
+ employeeString = "Unallocated";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ employeeString = employee is not null
|
|
|
+ ? (employee.ID == App.EmployeeID
|
|
|
+ ? App.EmployeeName
|
|
|
+ : employee.Name)
|
|
|
+ : "";
|
|
|
}
|
|
|
}
|
|
|
- catch (Exception e)
|
|
|
+
|
|
|
+ var managerString = "";
|
|
|
+ if (kanban.ManagerLink.ID != SelectedEmployee.ID)
|
|
|
{
|
|
|
- Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
|
|
|
+ if (kanban.ManagerLink.ID != Guid.Empty)
|
|
|
+ {
|
|
|
+ managerString = manager is not null
|
|
|
+ ? (manager.ID == App.EmployeeID
|
|
|
+ ? App.EmployeeName
|
|
|
+ : manager.Name)
|
|
|
+ : "";
|
|
|
+ }
|
|
|
}
|
|
|
+ model.Manager = managerString;
|
|
|
|
|
|
- StatusTasksHeaderTimeConverter.Tasks = _models;
|
|
|
- FilterKanbans();
|
|
|
- }
|
|
|
-
|
|
|
- private void FilterKanbans()
|
|
|
- {
|
|
|
- Progress.ShowModal("Loading", (progress) =>
|
|
|
- {
|
|
|
- Dispatcher.BeginInvoke(() => { Progress.Show("Loading"); });
|
|
|
- if (JobFilterID == Guid.Empty)
|
|
|
+ if (!string.IsNullOrEmpty(employeeString))
|
|
|
{
|
|
|
- var list = _models
|
|
|
- .Where(x => x.Search(Search.Text.Split()))
|
|
|
- .OrderBy(x => x.EmployeeID == EmployeeID ? 0 : 1).ThenBy(x => x.DueDate);
|
|
|
- Dispatcher.BeginInvoke(() => { Kanban.ItemsSource = list; });
|
|
|
+ if (!managerString.IsNullOrWhiteSpace() && !managerString.Equals(employeeString))
|
|
|
+ {
|
|
|
+ model.AssignedTo = $"Assigned to {employeeString} by {managerString}";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ model.AssignedTo = $"Assigned to {employeeString}";
|
|
|
+ }
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
- var list = _models
|
|
|
- .Where(x => x.Search(Search.Text.Split()) && x.JobSearch(JobFilterID))
|
|
|
- .OrderBy(x => x.EmployeeID == EmployeeID ? 0 : 1).ThenBy(x => x.DueDate);
|
|
|
- Dispatcher.BeginInvoke(() => { Kanban.ItemsSource = list; });
|
|
|
- }
|
|
|
- Task.Run(() =>
|
|
|
- {
|
|
|
- Thread.Sleep(500);
|
|
|
- Dispatcher.BeginInvoke(() =>
|
|
|
+ if (!managerString.IsNullOrWhiteSpace())
|
|
|
{
|
|
|
- Progress.Close();
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region Kanban Selection Stuff
|
|
|
+ model.AssignedTo = $"Allocated by {managerString}";
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- private void SelectColumn(KanbanColumn column, bool selected)
|
|
|
- {
|
|
|
- CheckedKanbans.Clear();
|
|
|
- if (selected)
|
|
|
+ model.JobID = kanban.JobLink.ID;
|
|
|
+ model.JobNumber = kanban.JobLink.JobNumber.NotWhiteSpaceOr("");
|
|
|
+ model.JobName = kanban.JobLink.Name;
|
|
|
+ model.Checked = SelectedTasks.Any(x => x.ID == model.ID);
|
|
|
+ model.Type = new KanbanType
|
|
|
+ {
|
|
|
+ ID = kanban.Type.ID,
|
|
|
+ Code = kanban.Type.Code
|
|
|
+ };
|
|
|
+ model.Number = kanban.Number;
|
|
|
+ }
|
|
|
+ catch(Exception e)
|
|
|
{
|
|
|
- CheckedKanbans.AddRange(_models.Where(x => Equals(x.Category, column.Categories)).Select(x => x.ID));
|
|
|
- foreach (var model in _models)
|
|
|
- model.Checked = Equals(model.Category, column.Categories);
|
|
|
+ CoreUtils.LogException("", e);
|
|
|
+ }
|
|
|
+ if(model is not null)
|
|
|
+ {
|
|
|
+ yield return model;
|
|
|
}
|
|
|
-
|
|
|
- FilterKanbans();
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- private void UnSelectAll_Click(object sender, RoutedEventArgs e)
|
|
|
+ /// <summary>
|
|
|
+ /// Take the full list of kanbans loaded from the database, and filter based on the search UI elements, filtering into the columns.
|
|
|
+ /// </summary>
|
|
|
+ private void FilterKanbans()
|
|
|
+ {
|
|
|
+ IEnumerable<TaskModel> filtered;
|
|
|
+ if (JobFilterID == Guid.Empty)
|
|
|
{
|
|
|
- var column = ((MenuItem)sender).Tag as KanbanColumn;
|
|
|
- SelectColumn(column, false);
|
|
|
+ filtered = AllTasks;
|
|
|
}
|
|
|
-
|
|
|
- private void SelectAll_Click(object sender, RoutedEventArgs e)
|
|
|
+ else
|
|
|
{
|
|
|
- var column = ((MenuItem)sender).Tag as KanbanColumn;
|
|
|
- SelectColumn(column, true);
|
|
|
+ filtered = AllTasks.Where(x => x.JobSearch(JobFilterID));
|
|
|
}
|
|
|
-
|
|
|
- //private IEnumerable<Guid> GetSelectedKanbanIDs(String currentid)
|
|
|
- //{
|
|
|
- // List<Guid> result = new List<Guid>();
|
|
|
- // if (!CheckedKanbans.Contains(currentid))
|
|
|
- // result.Add(Guid.Parse(currentid));
|
|
|
- // CheckedKanbans.ForEach((id) => result.Add(Guid.Parse(id)));
|
|
|
- // return result;
|
|
|
- //}
|
|
|
-
|
|
|
- //private Kanban[] GetSelectedKanbans(String currentid)
|
|
|
- //{
|
|
|
- // var ids = GetSelectedKanbanIDs(currentid);
|
|
|
- // return Host.LoadKanbans(ids).ToArray();
|
|
|
- //}
|
|
|
-
|
|
|
- private void CheckBox_Checked(object sender, RoutedEventArgs e)
|
|
|
+ if (!Host.KanbanSettings.StatusSettings.IncludeLocked)
|
|
|
{
|
|
|
- var task = ((CheckBox)sender).Tag as TaskModel;
|
|
|
- if (task == null)
|
|
|
- return;
|
|
|
- if (CheckedKanbans.Contains(task.ID))
|
|
|
- CheckedKanbans.Remove(task.ID);
|
|
|
- else
|
|
|
- CheckedKanbans.Add(task.ID);
|
|
|
+ filtered = filtered.Where(x => !x.Locked);
|
|
|
}
|
|
|
+ if (!Host.KanbanSettings.StatusSettings.IncludeObserved
|
|
|
+ && SelectedEmployee.ID != CoreUtils.FullGuid)
|
|
|
+ {
|
|
|
+ filtered = filtered.Where(x => x.EmployeeID == SelectedEmployee.ID || x.ManagerID == SelectedEmployee.ID);
|
|
|
+ }
|
|
|
+ if (!Host.KanbanSettings.StatusSettings.IncludeCompleted)
|
|
|
+ {
|
|
|
+ filtered = filtered.Where(x => x.CompletedDate.IsEmpty());
|
|
|
+ }
|
|
|
+ if (SelectedType != CoreUtils.FullGuid)
|
|
|
+ {
|
|
|
+ filtered = filtered.Where(x => x.Type.ID == SelectedType);
|
|
|
+ }
|
|
|
+ filtered = filtered.Where(x => x.Search(SearchText.Split()))
|
|
|
+ .OrderBy(x => x.EmployeeID == SelectedEmployee.ID ? 0 : 1)
|
|
|
+ .ThenBy(x => x.DueDate);
|
|
|
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region Context Menu Actions
|
|
|
+ SelectedTasks.Clear();
|
|
|
|
|
|
- private void CreateTask(object sender, RoutedEventArgs e)
|
|
|
+ foreach (var column in Columns)
|
|
|
{
|
|
|
- CreateKanban();
|
|
|
+ column.Tasks.Clear();
|
|
|
}
|
|
|
|
|
|
- private void Border_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
|
+ foreach (var task in filtered)
|
|
|
{
|
|
|
- if (e.ClickCount > 1)
|
|
|
+ var column = GetColumn(task.Category);
|
|
|
+ column?.Tasks.Add(task);
|
|
|
+ if (task.Checked)
|
|
|
{
|
|
|
- var task = ((Border)sender).Tag as TaskModel;
|
|
|
- DoEdit(task);
|
|
|
- e.Handled = true;
|
|
|
+ SelectedTasks.Add(task);
|
|
|
}
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- private void EditTask_Click(object sender, RoutedEventArgs e)
|
|
|
- {
|
|
|
- var task = ((MenuItem)e.Source).Tag as TaskModel;
|
|
|
- DoEdit(task);
|
|
|
- e.Handled = true;
|
|
|
- }
|
|
|
+ #endregion
|
|
|
|
|
|
- //private void CreateSetout_Click(object sender, RoutedEventArgs e)
|
|
|
- //{
|
|
|
- // MenuItem menu = sender as MenuItem;
|
|
|
- // TaskModel task = menu.Tag as TaskModel;
|
|
|
-
|
|
|
- // if (task.JobID.Equals(Guid.Empty))
|
|
|
- // {
|
|
|
- // MessageBox.Show("Please link this task to a job before creating a setout!");
|
|
|
- // return;
|
|
|
- // }
|
|
|
-
|
|
|
- // if (MessageBox.Show("This will convert this task into a Setout.\n\nDo you wish to continue?", "Confirmation", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
|
|
|
- // return;
|
|
|
-
|
|
|
- // ManufacturingTemplate template = new Client<ManufacturingTemplate>().Load(new Filter<ManufacturingTemplate>(x => x.Code).IsEqualTo("PRS")).FirstOrDefault();
|
|
|
- // if (template == null)
|
|
|
- // {
|
|
|
- // MessageBox.Show("[Pressing] Template does not exist!");
|
|
|
- // return;
|
|
|
- // }
|
|
|
-
|
|
|
- // String setoutnumber = "";
|
|
|
-
|
|
|
- // Progress.ShowModal("Creating Setout", (progress) =>
|
|
|
- // {
|
|
|
- // MultiQuery query = new MultiQuery();
|
|
|
-
|
|
|
- // query.Add<ManufacturingTemplateStage>(
|
|
|
- // new Filter<ManufacturingTemplateStage>(x => x.Template.ID).IsEqualTo(template.ID),
|
|
|
- // null,
|
|
|
- // new SortOrder<ManufacturingTemplateStage>(x => x.Sequence)
|
|
|
- // );
|
|
|
-
|
|
|
- // query.Add<Kanban>(
|
|
|
- // new Filter<Kanban>(x => x.ID).IsEqualTo(task.ID),
|
|
|
- // null,
|
|
|
- // null
|
|
|
- // );
|
|
|
-
|
|
|
- // query.Query();
|
|
|
-
|
|
|
- // ManufacturingTemplateStage[] tstages = query.Get<ManufacturingTemplateStage>().Rows.Select(x => x.ToObject<ManufacturingTemplateStage>()).ToArray();
|
|
|
-
|
|
|
- // Kanban kanban = query.Get<Kanban>().Rows.FirstOrDefault()?.ToObject<Kanban>();
|
|
|
-
|
|
|
- // progress.Report("Creating Setouts");
|
|
|
- // CoreTable setouts = new Client<Setout>().Query(
|
|
|
- // new Filter<Setout>(x => x.JobLink.ID).IsEqualTo(kanban.JobLink.ID),
|
|
|
- // new Columns<Setout>(x => x.JobLink.JobNumber, x => x.Number),
|
|
|
- // null
|
|
|
- // );
|
|
|
-
|
|
|
- // int ireq = 0;
|
|
|
- // String sreq = "";
|
|
|
- // while (true)
|
|
|
- // {
|
|
|
- // ireq++;
|
|
|
- // sreq = String.Format("{0}-{1:yyMMdd}-{2}", kanban.JobLink.JobNumber, DateTime.Now, ireq);
|
|
|
- // if (!setouts.Rows.Any(r => sreq.Equals(r.Get<Setout, String>(c => c.Number))))
|
|
|
- // break;
|
|
|
- // }
|
|
|
-
|
|
|
- // Setout setout = new Setout();
|
|
|
- // setout.Number = sreq;
|
|
|
- // setout.JobLink.ID = kanban.JobLink.ID; // = new Client<Job>().Load(new Filter<Job>(x => x.ID).IsEqualTo(kanban.JobLink.ID)).FirstOrDefault();
|
|
|
- // setout.Reference = kanban.Title;
|
|
|
-
|
|
|
- // var notes = kanban.Notes.ToList();
|
|
|
- // var description = kanban.Summary;
|
|
|
- // if (String.IsNullOrWhiteSpace(description))
|
|
|
- // description = CoreUtils.StripHTML(kanban.Description);
|
|
|
- // if (!String.IsNullOrWhiteSpace(description))
|
|
|
- // notes.Insert(0, description);
|
|
|
- // setout.Description = String.Join("\n==========================================\n", notes);
|
|
|
-
|
|
|
- // new Client<Setout>().Save(setout, "Created from Task");
|
|
|
- // setoutnumber = setout.Number;
|
|
|
-
|
|
|
- // progress.Report("Creating Manufacturing Packet");
|
|
|
-
|
|
|
- // ManufacturingPacket packet = new ManufacturingPacket()
|
|
|
- // {
|
|
|
- // Group = template.Factory.Name,
|
|
|
- // Serial = template.Code,
|
|
|
- // Title = kanban.Title,
|
|
|
- // Quantity = 1,
|
|
|
- // BarcodeQty = 1,
|
|
|
- // DueDate = kanban.DueDate
|
|
|
- // };
|
|
|
- // packet.SetoutLink.ID = setout.ID;
|
|
|
- // //packet.JobLink.ID = setout.JobLink.ID;
|
|
|
- // packet.ManufacturingTemplateLink.ID = template.ID;
|
|
|
- // packet.ManufacturingTemplateLink.Code = template.Code;
|
|
|
- // new Client<ManufacturingPacket>().Save(packet, "Created from Task");
|
|
|
-
|
|
|
- // List<ManufacturingPacketStage> pstages = new List<ManufacturingPacketStage>();
|
|
|
- // foreach (var tstage in tstages)
|
|
|
- // {
|
|
|
- // var pstage = new ManufacturingPacketStage()
|
|
|
- // {
|
|
|
- // Time = tstage.Time,
|
|
|
- // Sequence = tstage.Sequence,
|
|
|
- // SequenceType = tstage.SequenceType,
|
|
|
- // Started = DateTime.MinValue,
|
|
|
- // PercentageComplete = 0.0F,
|
|
|
- // Completed = DateTime.MinValue,
|
|
|
- // QualityChecks = tstage.QualityChecks,
|
|
|
- // QualityStatus = QualityStatus.NotChecked,
|
|
|
- // QualityNotes = "",
|
|
|
- // };
|
|
|
- // pstage.Parent.ID = packet.ID;
|
|
|
- // pstage.ManufacturingSectionLink.ID = tstage.Section.ID;
|
|
|
- // pstage.ManufacturingSectionLink.Name = tstage.Section.Name;
|
|
|
- // pstages.Add(pstage);
|
|
|
- // }
|
|
|
- // new Client<ManufacturingPacketStage>().Save(pstages, "Created from Task", (_, __) => { });
|
|
|
-
|
|
|
- // progress.Report("Processing Documents");
|
|
|
-
|
|
|
-
|
|
|
- // List<SetoutDocument> _setoutdocuments = new List<SetoutDocument>();
|
|
|
- // List<KanbanDocument> _kanbandocuments = new List<KanbanDocument>();
|
|
|
- // KanbanDocument[] docrefs = new Client<KanbanDocument>().Load(new Filter<KanbanDocument>(x => x.EntityLink.ID).IsEqualTo(kanban.ID));
|
|
|
- // foreach (var docref in docrefs)
|
|
|
- // {
|
|
|
- // Guid docid = ProcessSetoutDocument(docref);
|
|
|
- // var newdoc = new SetoutDocument();
|
|
|
- // newdoc.EntityLink.ID = setout.ID;
|
|
|
- // newdoc.DocumentLink.ID = docid;
|
|
|
- // _setoutdocuments.Add(newdoc);
|
|
|
-
|
|
|
- // if (docid != docref.DocumentLink.ID)
|
|
|
- // {
|
|
|
- // docref.DocumentLink.ID = docid;
|
|
|
- // _kanbandocuments.Add(docref);
|
|
|
- // }
|
|
|
- // }
|
|
|
- // new Client<SetoutDocument>().Save(_setoutdocuments, "Converted from Task", (_, __) => { });
|
|
|
- // new Client<KanbanDocument>().Save(_kanbandocuments, "Converted to PDF", (_, __) => { });
|
|
|
-
|
|
|
- // SetoutKanban link = new SetoutKanban();
|
|
|
- // link.Entity.ID = setout.ID;
|
|
|
- // link.Kanban.ID = kanban.ID;
|
|
|
- // new Client<SetoutKanban>().Save(link, "Converting Task -> Setout", (_, __) => { });
|
|
|
-
|
|
|
- // progress.Report("Updating Task");
|
|
|
- // kanban.Title = kanban.Title + " (" + setoutnumber + ")";
|
|
|
- // kanban.Locked = true;
|
|
|
- // new Client<Kanban>().Save(kanban, "Converting Kanban to Setout");
|
|
|
-
|
|
|
-
|
|
|
- // });
|
|
|
-
|
|
|
- // MessageBox.Show(String.Format("Created Setout {0}", setoutnumber));
|
|
|
-
|
|
|
- // Refresh();
|
|
|
-
|
|
|
- //}
|
|
|
-
|
|
|
- //private Guid ProcessSetoutDocument(KanbanDocument docref)
|
|
|
- //{
|
|
|
- // Guid result = docref.DocumentLink.ID;
|
|
|
-
|
|
|
- // String ext = System.IO.Path.GetExtension(docref.DocumentLink.FileName).ToLower();
|
|
|
-
|
|
|
- // if (ext.EndsWith("txt"))
|
|
|
- // {
|
|
|
- // var doc = new Client<Document>().Load(new Filter<Document>(x => x.ID).IsEqualTo(docref.DocumentLink.ID)).FirstOrDefault();
|
|
|
- // PdfDocument pdf = new PdfDocument();
|
|
|
- // PdfPage page = pdf.Pages.Add();
|
|
|
- // PdfGraphics graphics = page.Graphics;
|
|
|
- // PdfFont font = new PdfStandardFont(PdfFontFamily.Courier, 12);
|
|
|
- // String text = System.Text.Encoding.UTF8.GetString(doc.Data);
|
|
|
- // graphics.DrawString(text, font, PdfBrushes.Black, new PointF(0, 0));
|
|
|
- // MemoryStream ms = new MemoryStream();
|
|
|
- // pdf.Save(ms);
|
|
|
- // pdf.Close(true);
|
|
|
- // byte[] data = ms.ToArray();
|
|
|
- // var newdoc = new Document()
|
|
|
- // {
|
|
|
- // Data = data,
|
|
|
- // FileName = System.IO.Path.ChangeExtension(docref.DocumentLink.FileName, "pdf"),
|
|
|
- // CRC = CoreUtils.CalculateCRC(data),
|
|
|
- // TimeStamp = DateTime.Now,
|
|
|
- // };
|
|
|
- // new Client<Document>().Save(newdoc, "Converted from Text");
|
|
|
- // return newdoc.ID;
|
|
|
- // }
|
|
|
-
|
|
|
- // else if (ext.EndsWith("png") || ext.EndsWith("bmp") || ext.EndsWith("jpg") || ext.EndsWith("jpeg"))
|
|
|
- // {
|
|
|
- // var doc = new Client<Document>().Load(new Filter<Document>(x => x.ID).IsEqualTo(docref.DocumentLink.ID)).FirstOrDefault();
|
|
|
-
|
|
|
- // PdfBitmap image = new PdfBitmap(new MemoryStream(doc.Data));
|
|
|
- // PdfDocument pdf = new PdfDocument();
|
|
|
- // pdf.PageSettings.Orientation = image.Height > image.Width ? PdfPageOrientation.Portrait : PdfPageOrientation.Landscape;
|
|
|
- // pdf.PageSettings.Size = new SizeF(image.Width, image.Height);
|
|
|
- // PdfPage page = pdf.Pages.Add();
|
|
|
- // PdfGraphics graphics = page.Graphics;
|
|
|
- // graphics.DrawImage(image, 0.0F, 0.0F);
|
|
|
- // MemoryStream ms = new MemoryStream();
|
|
|
- // pdf.Save(ms);
|
|
|
- // pdf.Close(true);
|
|
|
- // byte[] data = ms.ToArray();
|
|
|
- // var newdoc = new Document()
|
|
|
- // {
|
|
|
- // Data = data,
|
|
|
- // FileName = System.IO.Path.ChangeExtension(docref.DocumentLink.FileName, "pdf"),
|
|
|
- // CRC = CoreUtils.CalculateCRC(data),
|
|
|
- // TimeStamp = DateTime.Now,
|
|
|
- // };
|
|
|
- // new Client<Document>().Save(newdoc, "Converted from Image");
|
|
|
- // return newdoc.ID;
|
|
|
- // }
|
|
|
-
|
|
|
- // return result;
|
|
|
-
|
|
|
- //}
|
|
|
-
|
|
|
- //private void CreateRequisition_Click(object sender, RoutedEventArgs e)
|
|
|
- //{
|
|
|
- // MenuItem menu = sender as MenuItem;
|
|
|
- // TaskModel task = menu.Tag as TaskModel;
|
|
|
-
|
|
|
- // if (task.JobID.Equals(Guid.Empty))
|
|
|
- // {
|
|
|
- // MessageBox.Show("Please link this task to a job before creating a requisition!");
|
|
|
- // return;
|
|
|
- // }
|
|
|
-
|
|
|
- // if (MessageBox.Show("This will convert this task into a Requisition.\n\nDo you wish to continue?", "Confirmation", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
|
|
|
- // return;
|
|
|
-
|
|
|
- // int requinumber = 0;
|
|
|
- // Progress.ShowModal("Creating Requisition", (progress) =>
|
|
|
- // {
|
|
|
- // Kanban kanban = new Client<Kanban>().Load(new Filter<Kanban>(x => x.ID).IsEqualTo(task.ID)).FirstOrDefault();
|
|
|
-
|
|
|
- // Requisition requi = new Requisition();
|
|
|
- // requi.JobLink.ID = kanban.JobLink.ID;
|
|
|
-
|
|
|
- // requi.RequestedBy.ID = kanban.ManagerLink.ID;
|
|
|
- // requi.Employee.ID = Guid.Empty;
|
|
|
- // requi.Title = kanban.Title;
|
|
|
-
|
|
|
- // requi.Request = String.IsNullOrWhiteSpace(kanban.Summary)
|
|
|
- // ? String.IsNullOrWhiteSpace(kanban.Summary)
|
|
|
- // ? String.Join("\n", kanban.Notes)
|
|
|
- // : CoreUtils.StripHTML(kanban.Description)
|
|
|
- // : kanban.Summary;
|
|
|
-
|
|
|
- // requi.Notes = kanban.Notes;
|
|
|
- // requi.Due = kanban.DueDate;
|
|
|
- // new Client<Requisition>().Save(requi, "Created from Task");
|
|
|
- // requinumber = requi.Number;
|
|
|
- // progress.Report("Updating Documents");
|
|
|
-
|
|
|
- // List<RequisitionDocument> _documents = new List<RequisitionDocument>();
|
|
|
- // KanbanDocument[] documents = new Client<KanbanDocument>().Load(new Filter<KanbanDocument>(x => x.EntityLink.ID).IsEqualTo(kanban.ID));
|
|
|
- // foreach (var document in documents)
|
|
|
- // {
|
|
|
- // var newdoc = new RequisitionDocument();
|
|
|
- // newdoc.EntityLink.ID = requi.ID;
|
|
|
- // newdoc.DocumentLink.ID = document.DocumentLink.ID;
|
|
|
- // _documents.Add(newdoc);
|
|
|
-
|
|
|
- // }
|
|
|
- // new Client<RequisitionDocument>().Save(_documents, "Converted from Task", (_, __) => { });
|
|
|
-
|
|
|
- // RequisitionKanban link = new RequisitionKanban();
|
|
|
- // link.Entity.ID = requi.ID;
|
|
|
- // link.Kanban.ID = kanban.ID;
|
|
|
- // new Client<RequisitionKanban>().Save(link, "Converting Task -> Requisition", (_, __) => { });
|
|
|
-
|
|
|
- // progress.Report("Updating Task");
|
|
|
- // kanban.Category = "Open";
|
|
|
- // kanban.Completed = DateTime.MinValue;
|
|
|
- // kanban.Locked = true;
|
|
|
- // kanban.Title = kanban.Title + " (Requi #" + requi.Number.ToString() + ")";
|
|
|
- // new Client<Kanban>().Save(kanban, "Converted to Requisition", (_, __) => { });
|
|
|
-
|
|
|
- // });
|
|
|
-
|
|
|
- // MessageBox.Show(String.Format("Created Requisition {0}", requinumber));
|
|
|
- // Refresh();
|
|
|
-
|
|
|
- //}
|
|
|
-
|
|
|
- //private void CreatePurchaseOrder_Click(object sender, RoutedEventArgs e)
|
|
|
- //{
|
|
|
- // MenuItem menu = sender as MenuItem;
|
|
|
- // TaskModel task = menu.Tag as TaskModel;
|
|
|
-
|
|
|
- // if (MessageBox.Show("This will convert this task into a Purchase Order.\n\nDo you wish to continue?", "Confirmation", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
|
|
|
- // {
|
|
|
- // String ponumber = "";
|
|
|
- // Progress.ShowModal("Creating Purchase Order", (progress) =>
|
|
|
- // {
|
|
|
-
|
|
|
- // Kanban kanban = new Client<Kanban>().Load(new Filter<Kanban>(x => x.ID).IsEqualTo(task.ID)).FirstOrDefault();
|
|
|
-
|
|
|
- // PurchaseOrder order = new PurchaseOrder();
|
|
|
- // order.Notes = kanban.Summary;
|
|
|
- // order.RaisedBy.ID = kanban.EmployeeLink.ID;
|
|
|
- // new Client<PurchaseOrder>().Save(order, "Created from Task Screen");
|
|
|
- // ponumber = order.PONumber;
|
|
|
-
|
|
|
- // progress.Report("Updating Documents");
|
|
|
- // List<PurchaseOrderDocument> docs = new List<PurchaseOrderDocument>();
|
|
|
- // var taskdocs = new Client<KanbanDocument>().Load(new Filter<KanbanDocument>(x => x.EntityLink.ID).IsEqualTo(Guid.Parse(task.ID)));
|
|
|
- // foreach (var taskdoc in taskdocs)
|
|
|
- // {
|
|
|
- // PurchaseOrderDocument doc = new PurchaseOrderDocument();
|
|
|
- // doc.DocumentLink.ID = taskdoc.DocumentLink.ID;
|
|
|
- // doc.EntityLink.ID = order.ID;
|
|
|
- // docs.Add(doc);
|
|
|
- // }
|
|
|
- // new Client<PurchaseOrderDocument>().Save(docs, "", (_, __) => { });
|
|
|
-
|
|
|
- // progress.Report("Creating Links");
|
|
|
- // PurchaseOrderKanban link = new PurchaseOrderKanban();
|
|
|
- // link.Entity.ID = order.ID;
|
|
|
- // link.Kanban.ID = kanban.ID;
|
|
|
- // new Client<PurchaseOrderKanban>().Save(link, "Converting Task -> Purchase Order", (_, __) => { });
|
|
|
-
|
|
|
- // progress.Report("Updating Task");
|
|
|
- // kanban.Category = "Open";
|
|
|
- // kanban.Completed = DateTime.MinValue;
|
|
|
- // kanban.Locked = true;
|
|
|
- // kanban.Title = "(PO#" + order.PONumber.ToString() + ") " + kanban.Title;
|
|
|
- // new Client<Kanban>().Save(kanban, "Converted to Purchase Order", (_, __) => { });
|
|
|
-
|
|
|
- // });
|
|
|
-
|
|
|
- // MessageBox.Show(String.Format("Created Purchase Order {0}", ponumber));
|
|
|
- // Refresh();
|
|
|
-
|
|
|
-
|
|
|
- // }
|
|
|
-
|
|
|
- //}
|
|
|
-
|
|
|
- //private void CreateDelivery_Click(object sender, RoutedEventArgs e)
|
|
|
- //{
|
|
|
- // MenuItem menu = sender as MenuItem;
|
|
|
- // TaskModel task = menu.Tag as TaskModel;
|
|
|
-
|
|
|
- // if (MessageBox.Show("This will convert this task into a Delivery.\n\nDo you wish to continue?", "Confirmation", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
|
|
|
- // return;
|
|
|
-
|
|
|
- // int deliverynumber = 0;
|
|
|
- // Progress.ShowModal("Creating Delivery", (progress) =>
|
|
|
- // {
|
|
|
- // Kanban kanban = new Client<Kanban>().Query(new Filter<Kanban>(x => x.ID).IsEqualTo(task.ID)).Rows.FirstOrDefault()?.ToObject<Kanban>();
|
|
|
-
|
|
|
- // Delivery delivery = new Delivery();
|
|
|
- // delivery.Due = kanban.DueDate;
|
|
|
- // delivery.Job.ID = kanban.JobLink.ID;
|
|
|
- // delivery.Job.Synchronise(kanban.JobLink);
|
|
|
- // delivery.Notes = kanban.Summary;
|
|
|
- // delivery.Employee.ID = kanban.ManagerLink.ID;
|
|
|
- // delivery.Employee.Synchronise(kanban.ManagerLink);
|
|
|
- // new Client<Delivery>().Save(delivery, "Created From Task");
|
|
|
- // deliverynumber = delivery.Number;
|
|
|
-
|
|
|
- // progress.Report("Updating Documents");
|
|
|
- // List<DeliveryDocument> docs = new List<DeliveryDocument>();
|
|
|
- // var taskdocs = new Client<KanbanDocument>().Load(new Filter<KanbanDocument>(x => x.EntityLink.ID).IsEqualTo(Guid.Parse(task.ID)));
|
|
|
- // foreach (var taskdoc in taskdocs)
|
|
|
- // {
|
|
|
- // DeliveryDocument doc = new DeliveryDocument();
|
|
|
- // doc.DocumentLink.ID = taskdoc.DocumentLink.ID;
|
|
|
- // doc.EntityLink.ID = delivery.ID;
|
|
|
- // docs.Add(doc);
|
|
|
- // }
|
|
|
- // new Client<DeliveryDocument>().Save(docs, "", (_, __) => { });
|
|
|
-
|
|
|
- // progress.Report("Creating Links");
|
|
|
- // DeliveryKanban link = new DeliveryKanban();
|
|
|
- // link.Entity.ID = delivery.ID;
|
|
|
- // link.Kanban.ID = kanban.ID;
|
|
|
- // new Client<DeliveryKanban>().Save(link, "Converting Task -> Delivery", (_, __) => { });
|
|
|
-
|
|
|
- // progress.Report("Updating Task");
|
|
|
- // kanban.Category = "Open";
|
|
|
- // kanban.Completed = DateTime.MinValue;
|
|
|
- // kanban.Locked = true;
|
|
|
- // kanban.Title = "(Del#" + delivery.Number.ToString() + ") " + kanban.Title;
|
|
|
- // new Client<Kanban>().Save(kanban, "Converted to Delivery", (_, __) => { });
|
|
|
-
|
|
|
- // });
|
|
|
-
|
|
|
- // MessageBox.Show(String.Format("Created Delivery {0}", deliverynumber));
|
|
|
- // Refresh();
|
|
|
-
|
|
|
- //}
|
|
|
-
|
|
|
- //private void CloseTask_Click(object sender, RoutedEventArgs e)
|
|
|
- //{
|
|
|
- // if (MessageBox.Show("Are you sure you want to remove the selected tasks from the list?", "Confirm removal", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
|
|
|
- // return;
|
|
|
- // Progress.ShowModal("Closing Kanbans", (progress) =>
|
|
|
- // {
|
|
|
- // TaskModel task = ((MenuItem)e.Source).Tag as TaskModel;
|
|
|
-
|
|
|
- // Kanban[] kanbans = GetSelectedKanbans(task.ID);
|
|
|
- // for (int i = 0; i < kanbans.Length; i++)
|
|
|
- // {
|
|
|
- // Kanban kanban = kanbans[i];
|
|
|
- // kanban.Closed = DateTime.Now;
|
|
|
- // }
|
|
|
- // new Client<Kanban>().Save(kanbans, "Kanban Marked as Closed");
|
|
|
- // CheckedKanbans.Clear();
|
|
|
-
|
|
|
- // });
|
|
|
- // Refresh();
|
|
|
-
|
|
|
- //}
|
|
|
-
|
|
|
- //private void EmailTask_Click(object sender, RoutedEventArgs e)
|
|
|
- //{
|
|
|
-
|
|
|
- // MenuItem menu = sender as MenuItem;
|
|
|
- // TaskModel task = menu.Tag as TaskModel;
|
|
|
- // Kanban kanban = new Client<Kanban>().Load(new Filter<Kanban>(x => x.ID).IsEqualTo(task.ID)).FirstOrDefault();
|
|
|
-
|
|
|
- // List<String> to = new List<string>();
|
|
|
-
|
|
|
- // String from = "";
|
|
|
- // String salutation = "";
|
|
|
-
|
|
|
- // if (MyID.HasValue)
|
|
|
- // {
|
|
|
-
|
|
|
- // CoreRow me = _employees.Rows.FirstOrDefault(r => r.Get<Employee, Guid>(c => c.ID).Equals(MyID));
|
|
|
- // if (me != null)
|
|
|
- // from = me.Get<Employee, String>(c => c.Name).Split(' ').FirstOrDefault();
|
|
|
-
|
|
|
- // if (kanban.EmployeeLink.ID != MyID.Value)
|
|
|
- // {
|
|
|
- // CoreRow emp = _employees.Rows.FirstOrDefault(r => r.Get<Employee, Guid>(c => c.ID).Equals(kanban.EmployeeLink.ID));
|
|
|
- // if (emp != null)
|
|
|
- // {
|
|
|
- // String email = emp.Get<Employee, String>(c => c.Email);
|
|
|
- // if (!string.IsNullOrEmpty(email))
|
|
|
- // {
|
|
|
- // to.Add(email);
|
|
|
- // String name = emp.Get<Employee, String>(c => c.Name).Split(' ').FirstOrDefault();
|
|
|
- // salutation = salutation + (String.IsNullOrEmpty(salutation) ? "Hi " : " and ") + name;
|
|
|
- // }
|
|
|
-
|
|
|
- // }
|
|
|
- // }
|
|
|
-
|
|
|
- // if (kanban.ManagerLink.ID != MyID.Value)
|
|
|
- // {
|
|
|
- // CoreRow emp = _employees.Rows.FirstOrDefault(r => r.Get<Employee, Guid>(c => c.ID).Equals(kanban.ManagerLink.ID));
|
|
|
- // if (emp != null)
|
|
|
- // {
|
|
|
- // String email = emp.Get<Employee, String>(c => c.Email);
|
|
|
- // if (!string.IsNullOrEmpty(email))
|
|
|
- // {
|
|
|
- // to.Add(email);
|
|
|
- // String name = emp.Get<Employee, String>(c => c.Name).Split(' ').FirstOrDefault();
|
|
|
- // salutation = salutation + (String.IsNullOrEmpty(salutation) ? "Hi " : " and ") + name;
|
|
|
- // }
|
|
|
- // }
|
|
|
- // }
|
|
|
- // }
|
|
|
-
|
|
|
- // Outlook.Application outlookApp = new Outlook.Application();
|
|
|
- // Outlook.MailItem mailItem = (Outlook.MailItem)outlookApp.CreateItem(Outlook.OlItemType.olMailItem);
|
|
|
- // mailItem.Subject = "PRS Task: " + kanban.Title;
|
|
|
- // mailItem.To = String.Join("; ", to);
|
|
|
- // mailItem.HTMLBody = String.Format("{0},<br><br>Please see the above task in PRS.<br><br>Regards,<br><br>{1}<br><br><b><u>Task Description:</u></b><br><i>{2}</i><br><br><b><u>Additional Notes:</u></b><br>{3}", salutation, from, CoreUtils.StripHTML(kanban.Description), String.Join("\r\n", kanban.Notes));
|
|
|
- // //mailItem.Attachments.Add(filename, Outlook.OlAttachmentType.olByValue, Type.Missing, Type.Missing);
|
|
|
- // mailItem.Display(false);
|
|
|
- //}
|
|
|
-
|
|
|
- //private void CompleteTask_Click(object sender, RoutedEventArgs e)
|
|
|
- //{
|
|
|
- // if (MessageBox.Show("Are you sure you want to mark the selected tasks as complete?", "Confirm Completion", MessageBoxButton.YesNo) != MessageBoxResult.Yes)
|
|
|
- // return;
|
|
|
- // TaskModel task = ((MenuItem)e.Source).Tag as TaskModel;
|
|
|
- // Progress.ShowModal("Completing Task", (progress) =>
|
|
|
- // {
|
|
|
-
|
|
|
- // Kanban[] kanbans = GetSelectedKanbans(task.ID);
|
|
|
- // for (int i = 0; i < kanbans.Length; i++)
|
|
|
- // {
|
|
|
- // Kanban kanban = kanbans[i];
|
|
|
- // kanban.Completed = DateTime.Now;
|
|
|
- // kanban.Category = "Complete";
|
|
|
- // }
|
|
|
- // new Client<Kanban>().Save(kanbans, "Kanban Marked as Completed");
|
|
|
- // CheckedKanbans.Clear();
|
|
|
-
|
|
|
- // });
|
|
|
- // Refresh();
|
|
|
- //}
|
|
|
-
|
|
|
- #endregion
|
|
|
-
|
|
|
- #region Kanban Creation / Editing
|
|
|
-
|
|
|
- public void CreateKanban()
|
|
|
- {
|
|
|
- var result = Host.CreateKanban(
|
|
|
- kanban =>
|
|
|
- {
|
|
|
- kanban.EmployeeLink.ID = EmployeeID != CoreUtils.FullGuid ? EmployeeID : MyID.Value;
|
|
|
- kanban.ManagerLink.ID = MyID.Value;
|
|
|
- kanban.ManagerLink.UserLink.ID = ClientFactory.UserGuid;
|
|
|
- });
|
|
|
- if (result != null)
|
|
|
- Refresh(true);
|
|
|
- }
|
|
|
+ #region ITaskControl
|
|
|
|
|
|
- private void DoEdit(TaskModel task)
|
|
|
- {
|
|
|
- if (task == null)
|
|
|
- return;
|
|
|
+ public ITaskHost Host { get; set; }
|
|
|
|
|
|
- var result = Host.EditReferences(new[] { task });
|
|
|
- if (result)
|
|
|
- Refresh(true);
|
|
|
- }
|
|
|
+ public KanbanViewType KanbanViewType => KanbanViewType.Status;
|
|
|
+
|
|
|
+ public bool IsReady { get; set; }
|
|
|
|
|
|
- #endregion
|
|
|
+ public string SectionName => "Tasks By Status";
|
|
|
+
|
|
|
+ public DataModel DataModel(Selection selection)
|
|
|
+ {
|
|
|
+ var ids = SelectedModels().Select(x => x.ID).ToArray();
|
|
|
+ return new AutoDataModel<Kanban>(new Filter<Kanban>(x => x.ID).InList(ids));
|
|
|
+ }
|
|
|
|
|
|
- private void TaskTypesLabel_OnClick(object sender, RoutedEventArgs e)
|
|
|
+ public IEnumerable<TaskModel> SelectedModels(TaskModel? sender = null)
|
|
|
+ {
|
|
|
+ if(sender is null)
|
|
|
{
|
|
|
- var list = new MasterList(typeof(KanbanType));
|
|
|
- list.ShowDialog();
|
|
|
- SetupKanbanTypesLookup(true);
|
|
|
+ return SelectedTasks;
|
|
|
}
|
|
|
-
|
|
|
- private void JobFilterBtn_OnClick(object sender, RoutedEventArgs e)
|
|
|
+ else
|
|
|
{
|
|
|
- if (JobFilterID != Guid.Empty)
|
|
|
+ var result = SelectedTasks.ToList();
|
|
|
+ if (!result.Contains(sender))
|
|
|
{
|
|
|
- JobFilterBtn.Content = "Filter Job";
|
|
|
- JobFilterID = Guid.Empty;
|
|
|
- FilterKanbans();
|
|
|
- return;
|
|
|
+ result.Add(sender);
|
|
|
}
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- var window = new ThemableWindow();
|
|
|
- var grid = new JobGrid();
|
|
|
- grid.Reconfigure(options =>
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ private void Export_Click(object sender, RoutedEventArgs e)
|
|
|
+ {
|
|
|
+ var form = new DynamicExportForm(typeof(Kanban), GetKanbanColumns().ColumnNames());
|
|
|
+ if (form.ShowDialog() != true)
|
|
|
+ return;
|
|
|
+ var export = new Client<Kanban>().Query(
|
|
|
+ GetKanbanFilter(),
|
|
|
+ new Columns<Kanban>(form.Fields),
|
|
|
+ LookupFactory.DefineSort<Kanban>()
|
|
|
+ );
|
|
|
+
|
|
|
+ var employee = "Tasks for All Staff";
|
|
|
+ if (SelectedEmployee.ID != CoreUtils.FullGuid)
|
|
|
+ {
|
|
|
+ if (SelectedEmployee.ID == Guid.Empty)
|
|
|
{
|
|
|
- options.Remove(DynamicGridOption.EditRows);
|
|
|
- options.Remove(DynamicGridOption.DeleteRows);
|
|
|
- options.Remove(DynamicGridOption.AddRows);
|
|
|
- options.Remove(DynamicGridOption.MultiSelect);
|
|
|
- options.Remove(DynamicGridOption.ExportData);
|
|
|
- options.Remove(DynamicGridOption.ImportData);
|
|
|
- });
|
|
|
- grid.OnSelectItem += (object sender, DynamicGridSelectionEventArgs e) =>
|
|
|
+ employee = "Unallocated Tasks";
|
|
|
+ }
|
|
|
+ else
|
|
|
{
|
|
|
- if ((sender as JobGrid).SelectedRows.Count() == 0)
|
|
|
- return;
|
|
|
-
|
|
|
- else
|
|
|
- {
|
|
|
- var item = (sender as JobGrid).SelectedRows[0];
|
|
|
- AddJobFilter(item);
|
|
|
- window.Close();
|
|
|
- }
|
|
|
- };
|
|
|
- grid.Refresh(true, true);
|
|
|
- window.Content = grid;
|
|
|
- window.ShowDialog();
|
|
|
+ var model = Employees.FirstOrDefault(x => x.ID == SelectedEmployee.ID);
|
|
|
+ employee = model == null ? "Tasks for (Unknown)" : "Tasks for " + (model.ID == App.EmployeeID ? App.EmployeeName : model.Name);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- Guid JobFilterID = Guid.Empty;
|
|
|
+ ExcelExporter.DoExport<Kanban>(
|
|
|
+ export,
|
|
|
+ string.Format(
|
|
|
+ "{0} ({1:dd-MMM-yy})",
|
|
|
+ employee,
|
|
|
+ DateTime.Today
|
|
|
+ )
|
|
|
+ );
|
|
|
+ }
|
|
|
|
|
|
- private void AddJobFilter(CoreRow item)
|
|
|
+ private KanbanViewMode _mode;
|
|
|
+ public KanbanViewMode Mode
|
|
|
+ {
|
|
|
+ get => _mode;
|
|
|
+ set
|
|
|
{
|
|
|
- JobFilterID = item.Get<Job, Guid>(x => x.ID);
|
|
|
- JobFilterBtn.Content = item.Get<Job, string>(x => x.JobNumber) + " (click to cancel)";
|
|
|
- FilterKanbans();
|
|
|
+ _mode = value;
|
|
|
+ OnPropertyChanged();
|
|
|
}
|
|
|
}
|
|
|
-}
|
|
|
+
|
|
|
+ private void ViewType_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
|
+ {
|
|
|
+ if (!IsReady || EventSuppressor.IsSet(Suppress.This))
|
|
|
+ return;
|
|
|
+ Mode = ViewType.SelectedIndex switch
|
|
|
+ {
|
|
|
+ 0 => KanbanViewMode.Full,
|
|
|
+ 1 => KanbanViewMode.Compact,
|
|
|
+ _ => KanbanViewMode.Full
|
|
|
+ };
|
|
|
+
|
|
|
+ Host.KanbanSettings.StatusSettings.CompactView = Mode == KanbanViewMode.Compact;
|
|
|
+ Host.SaveSettings();
|
|
|
+ }
|
|
|
+}
|
