1 files changed, 290 insertions, 0 deletions
diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ActionLogs/ViewModels/MainViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ActionLogs/ViewModels/MainViewVM.cs
new file mode 100644
index 000000000..3e5c59fee
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ActionLogs/ViewModels/MainViewVM.cs
@@ -0,0 +1,290 @@
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Data.Entity;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using Tango.BL;
+using Tango.BL.Builders;
+using Tango.BL.Entities;
+using Tango.BL.Enumerations;
+using Tango.BL.ValueObjects;
+using Tango.Core.Commands;
+using Tango.Core.ExtensionMethods;
+using Tango.MachineStudio.Common;
+using Tango.MachineStudio.Common.Notifications;
+using Tango.SharedUI.Components;
+
+namespace Tango.MachineStudio.ActionLogs.ViewModels
+{
+    public class MainViewVM : StudioViewModel
+    {
+        private INotificationProvider _notification;
+        private List<User> _allUsers;
+
+        #region Properties
+
+        private DateTime _startSelectedDate;
+        public DateTime StartSelectedDate
+        {
+            get { return _startSelectedDate; }
+            set { _startSelectedDate = value; RaisePropertyChangedAuto(); }
+        }
+
+        private DateTime _endSelectedDate;
+        public DateTime EndSelectedDate
+        {
+            get { return _endSelectedDate; }
+            set { _endSelectedDate = value; RaisePropertyChangedAuto(); }
+        }
+
+        private string _searchFilter;
+        public string SearchFilter
+        {
+            get { return _searchFilter; }
+            set { _searchFilter = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<ActionLog> _actionLogs;
+        public ObservableCollection<ActionLog> ActionLogs
+        {
+            get { return _actionLogs; }
+            set { _actionLogs = value; RaisePropertyChanged(nameof(ActionLogs)); }
+        }
+
+        private SelectedObjectCollection<ActionLogType> _selectedActionLogTypes;
+        public SelectedObjectCollection<ActionLogType> SelectedActionLogTypes
+        {
+            get { return _selectedActionLogTypes; }
+            set
+            {
+                _selectedActionLogTypes = value;
+                RaisePropertyChanged(nameof(SelectedActionLogTypes));
+            }
+        }
+
+        private ActionLog _selectedActionLog = null;
+        public ActionLog SelectedActionLog
+        {
+            get { return _selectedActionLog; }
+            set
+            {
+                _selectedActionLog = value;
+                SelectedItemChanged();
+                RaisePropertyChangedAuto();
+                InvalidateRelayCommands();
+            }
+        }
+
+        private ActionLogDifference _differenceObject;
+        public ActionLogDifference DifferenceObject
+        {
+            get { return _differenceObject; }
+            set { _differenceObject = value; RaisePropertyChangedAuto(); }
+        }
+
+        private bool _isLoading;
+
+        public bool IsLoading
+        {
+            get { return _isLoading; }
+            set { _isLoading = value; RaisePropertyChangedAuto(); }
+        }
+
+        private bool _isLoadingDifferences;
+
+        public bool IsLoadingDifferences
+        {
+            get { return _isLoadingDifferences; }
+            set { _isLoadingDifferences = value; RaisePropertyChangedAuto(); }
+        }
+
+
+
+
+        #endregion
+
+        public RelayCommand SearchCommand { get; set; }
+        public RelayCommand CopyToClipBoardCommand { get; set; }
+        public RelayCommand CopyRelateObjectIDCommand { get; set; }
+
+        public MainViewVM(INotificationProvider notification)
+        {
+            _notification = notification;
+
+            IsLoading = false;
+            IsLoadingDifferences = false;
+            ActionLogs = new ObservableCollection<ActionLog>();
+            SearchCommand = new RelayCommand(async () => await GetActionLogs(), () => IsFree);
+            CopyRelateObjectIDCommand = new RelayCommand(CopyRelateObjectID);
+            CopyToClipBoardCommand = new RelayCommand(CopyToClipBoard, () => SelectedActionLog != null && SelectedActionLog.DifferenceObject != null);
+            DateTime now = DateTime.Now;
+            StartSelectedDate = now.AddMonths(-1);
+            EndSelectedDate = now;
+            var source = Enum.GetValues(typeof(ActionLogType)).Cast<ActionLogType>().ToObservableCollection();
+            var syncedSource = Enum.GetValues(typeof(ActionLogType)).Cast<ActionLogType>().ToObservableCollection();
+
+            SelectedActionLogTypes = new SelectedObjectCollection<ActionLogType>(source, syncedSource);
+        }
+
+        public override void OnApplicationReady()
+        {
+            InitUsers();
+        }
+        public async void InitUsers()
+        {
+            try
+            {
+                IsFree = false;
+
+                using (var db = ObservablesContext.CreateDefault())
+                {
+
+                    _allUsers = await db.Users.Include(x => x.Contact).ToListAsync();
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, "Error loading users.");
+            }
+            finally
+            {
+                IsFree = true;
+            }
+        }
+
+        private void CopyToClipBoard()
+        {
+            DataObject data = new DataObject(SelectedActionLog.DifferenceObject.ToJsonString());
+            System.Windows.Clipboard.SetDataObject(data);
+
+        }
+        private void CopyRelateObjectID()
+        {
+            DataObject data = new DataObject(SelectedActionLog.RelatedObjectGuid);
+            System.Windows.Clipboard.SetDataObject(data);
+        }
+        
+        /// <summary>
+        /// New Database Query with search parameters. Initialization ActionLogs property.
+        /// </summary>
+        private async Task GetActionLogs()
+        {
+            IsLoading = true;
+            string filter = SearchFilter?.ToLower();
+
+            if (String.IsNullOrWhiteSpace(filter)) filter = null;
+
+            try
+            {
+                IsFree = false;
+
+                using (ObservablesContext db = ObservablesContext.CreateDefault())
+                {
+                    DateTime startUtc = new DateTime(StartSelectedDate.Year, StartSelectedDate.Month, StartSelectedDate.Day, 0, 0, 0).ToUniversalTime();
+                    TimeSpan offsetTime = (EndSelectedDate.Date == DateTime.Now.Date) ? DateTime.Now.TimeOfDay : new TimeSpan(23, 59, 59);
+                    DateTime endUtc = EndSelectedDate.ToUniversalTime() + offsetTime;
+
+                    Debug.Write($"TEST TIME {startUtc} to {endUtc}  "+ System.Environment.NewLine);
+
+                    var db_ActionLogs = db.ActionLogs.Where(x => x.LastUpdated <= endUtc && x.LastUpdated >= startUtc)
+                           .Select(x => new
+                           {
+                               x.ID,
+                               x.Guid,
+                               x.UserGuid,
+                               x.LastUpdated,
+                               x.Type,
+                               x.RelatedObjectName,
+                               x.RelatedObjectGuid,
+                               x.Message
+                           });
+
+                    int[] actionTypes = SelectedActionLogTypes.SynchedSource.ToArray().Select(x => (int)x).ToArray();
+                    if (actionTypes.Length > 0)
+                    {
+                        db_ActionLogs = db_ActionLogs.Where(x => actionTypes.Contains(x.Type));
+                    }
+
+                    var runs_db = await db_ActionLogs.ToListAsync();
+                    var runs = runs_db.Select(x => new ActionLog()
+                             {
+                                 ID = x.ID,
+                                 Guid = x.Guid,
+                                 UserGuid = x.UserGuid,
+                                 LastUpdated = x.LastUpdated,
+                                 Type = x.Type,
+                                 RelatedObjectName = x.RelatedObjectName,
+                                 RelatedObjectGuid = x.RelatedObjectGuid,
+                                 Message = x.Message,
+                                 User = _allUsers.SingleOrDefault(y => y.Guid == x.UserGuid)
+                             });
+
+                    if (!String.IsNullOrEmpty(filter))
+                    {
+                        runs = runs.Where(x => x.ID.ToString().ToLower().StartsWith(filter) || (x.RelatedObjectName != null && x.RelatedObjectName.ToLower().StartsWith(filter))
+                        || (x.RelatedObjectGuid != null && x.RelatedObjectGuid.ToLower().StartsWith(filter))
+                        || (x.User != null && x.User.Contact != null && x.User.Contact.FullName.ToLower().StartsWith(filter)));
+                    }
+                    ActionLogs = runs.ToObservableCollection();
+                }
+            }
+            catch (Exception ex)
+            {
+                IsFree = true;
+                LogManager.Log(ex, "Error getting action logs.");
+                _notification.ShowError($"Error occurred while trying to retrieve the action logs.\n{ex.Message}");
+            }
+            finally
+            {
+                IsFree = true;
+                IsLoading = false;
+            }
+        }
+
+        /// <summary>
+        /// Update DifferenceObject on Selected item changed
+        /// </summary>
+        private async void SelectedItemChanged()
+        {
+            if (SelectedActionLog == null)
+                return;
+            if (SelectedActionLog.Difference == null)
+            {
+                await InitSelectedActionLogDifference();
+            }
+            DifferenceObject = SelectedActionLog.DifferenceObject;
+        }
+
+        /// <summary>
+        /// Initializes the selected action log difference.
+        /// </summary>
+        public async Task InitSelectedActionLogDifference()
+        {
+            IsLoadingDifferences = true;
+            try
+            {
+                using (var db = ObservablesContext.CreateDefault())
+                {
+                    var difference = await db.ActionLogs.SingleOrDefaultAsync(x => x.Guid.Equals(SelectedActionLog.Guid));
+                    if (difference != null)
+                    {
+                        SelectedActionLog.DifferenceObject = difference.DifferenceObject;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, "Error loading difference of the selected action log.");
+            }
+            finally
+            {
+                IsLoadingDifferences = false;
+            }
+        }
+    }
+}