MERGE Vica changes.

1 files changed, 1130 insertions, 0 deletions

diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/MainViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/MainViewVM.cs
new file mode 100644
index 000000000..10ec55958
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.ThreadExtensions/ViewModels/MainViewVM.cs
@@ -0,0 +1,1130 @@
+using Microsoft.Win32;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Data;
+using Tango.BL;
+using Tango.BL.Builders;
+using Tango.BL.Calibration;
+using Tango.BL.Entities;
+using Tango.Core.Commands;
+using Tango.MachineStudio.Common;
+using Tango.MachineStudio.Common.Notifications;
+
+
+using System.Data.Entity;
+using Tango.Core.ExtensionMethods;
+using Tango.MachineStudio.Common.Authentication;
+using Tango.BL.ActionLogs;
+using Tango.BL.DTO;
+using Tango.BL.Enumerations;
+using Tango.MachineStudio.ThreadExtensions.Contracts;
+using Tango.MachineStudio.ThreadExtensions.Views;
+using Tango.MachineStudio.ThreadExtensions.Models;
+using Tango.Settings;
+using System.Reflection;
+
+namespace Tango.MachineStudio.ThreadExtensions.ViewModels
+{
+    public class MainViewVM : StudioViewModel<IMainView>
+    {
+        private INotificationProvider _notification;
+        private IAuthenticationProvider _authentication;
+        private IActionLogManager _actionLogManager;
+
+        private ObservablesContext _rmlExtentions_context;
+        private ObservablesContext _active_context;
+
+        private List<User> _allUsers;
+
+        #region properties
+        //private ObservableCollection<RmlsExtension> _rmlsExtension;
+        //public ObservableCollection<RmlsExtension> RmlsExtensions
+        //{
+        //    get { return _rmlsExtension; }
+        //    set { _rmlsExtension = value;
+        //        RaisePropertyChangedAuto(); }
+        //}
+
+        private List<RmlExtensionModel> _rmlExtensions;
+        public List<RmlExtensionModel> RmlExtensions
+        {
+            get { return _rmlExtensions; }
+            set { _rmlExtensions = value;
+                RaisePropertyChangedAuto(); }
+        }
+
+        private RmlsExtension _ActiveRMLExtension;
+        public RmlsExtension ActiveRMLExtension
+        {
+            get { return _ActiveRMLExtension; }
+            set { _ActiveRMLExtension = value;
+                RaisePropertyChangedAuto(); }
+        }
+
+        private Rml _activeRML;
+        public Rml ActiveRML
+        {
+            get { return _activeRML; }
+            set
+            {
+                _activeRML = value;
+                RaisePropertyChangedAuto();
+            }
+        }
+
+        private RmlExtensionModel _selectedRMLExtension;
+        public RmlExtensionModel SelectedRMLExtension
+        {
+            get { return _selectedRMLExtension; }
+            set { _selectedRMLExtension = value;
+                RaisePropertyChangedAuto();
+                InvalidateRelayCommands(); }
+        }
+
+        //private ICollectionView _rmlExtCollectionView;
+        ///// <summary>
+        ///// Gets or sets the RML collection view.
+        ///// </summary>
+        //public ICollectionView RmlExtCollectionView
+        //{
+        //    get { return _rmlExtCollectionView; }
+        //    set
+        //    {
+        //        _rmlExtCollectionView = value;
+        //        RaisePropertyChangedAuto();
+        //    }
+        //}
+
+        private ObservableCollection<YarnApplication> _applications;
+        public ObservableCollection<YarnApplication> Applications
+        {
+            get { return _applications; }
+            set { _applications = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<YarnBrand> _brands;
+        public ObservableCollection<YarnBrand> Brands
+        {
+            get { return _brands; }
+            set { _brands = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<YarnWhiteShade> _yarnWhiteShade;
+        public ObservableCollection<YarnWhiteShade> YarnWhiteShade
+        {
+            get { return _yarnWhiteShade; }
+            set { _yarnWhiteShade = value; RaisePropertyChangedAuto(); }
+        }
+        private ObservableCollection<MediaPurpos> _enduse;
+        public ObservableCollection<MediaPurpos> EndUse
+        {
+            get { return _enduse; }
+            set { _enduse = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<LinearMassDensityUnit> _units;
+        public ObservableCollection<LinearMassDensityUnit> Units
+        {
+            get { return _units; }
+            set { _units = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<YarnFamily> _family;
+        public ObservableCollection<YarnFamily> Family
+        {
+            get { return _family; }
+            set { _family = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<FiberShape> _geometry;
+        public ObservableCollection<FiberShape> Geometry
+        {
+            get { return _geometry; }
+            set { _geometry = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<YarnGlossLevel> _glosslevel;
+        public ObservableCollection<YarnGlossLevel> GlossLevel
+        {
+            get { return _glosslevel; }
+            set { _glosslevel = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<YarnGroup> _group;
+        public ObservableCollection<YarnGroup> Group
+        {
+            get { return _group; }
+            set { _group = value; RaisePropertyChangedAuto(); }
+        }
+        
+        private List<String> _manufacturers;
+
+        public List<String> Manufacturers
+        {
+            get { return _manufacturers; }
+            set { _manufacturers = value;
+                RaisePropertyChangedAuto();
+            }
+        }
+
+
+        private ObservableCollection<MediaMaterial> _materials;
+        public ObservableCollection<MediaMaterial> Materials
+        {
+            get { return _materials; }
+            set { _materials = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<YarnSubFamily> _subFamilies;
+        public ObservableCollection<YarnSubFamily> SubFamilies
+        {
+            get { return _subFamilies; }
+            set { _subFamilies = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<YarnTexturing> _texturing;
+        public ObservableCollection<YarnTexturing> Texturing
+        {
+            get { return _texturing; }
+            set { _texturing = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<YarnType> _yarnTypes;
+        public ObservableCollection<YarnType> YarnTypes
+        {
+            get { return _yarnTypes; }
+            set { _yarnTypes = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<YarnIndustrysector> _industrySector;
+        public ObservableCollection<YarnIndustrysector> IndustrySector
+        {
+            get { return _industrySector; }
+            set { _industrySector = value; RaisePropertyChangedAuto(); }
+        }
+
+        private String _Filter;
+        /// <summary>
+        /// Gets or sets the search filter.
+        /// </summary>
+        public String Filter
+        {
+            get { return _Filter; }
+            set { _Filter = value; RaisePropertyChangedAuto(); OnFilterChanged(); }
+        }
+
+        private async void OnFilterChanged()
+        {
+            await LoadRmlExtentions();
+        }
+
+        private ColorParametersVewVM _colorParametersVewVM;
+        public ColorParametersVewVM ColorParametersVewVM
+        {
+            get { return _colorParametersVewVM; }
+            set { _colorParametersVewVM = value; RaisePropertyChangedAuto(); }
+        }
+
+        private TestResultsViewVM _testResultsViewVM;
+        public TestResultsViewVM TestResultsViewVM
+        {
+            get { return _testResultsViewVM; }
+            set { _testResultsViewVM = value; RaisePropertyChangedAuto(); }
+        }
+
+        protected MachineModel _selectedMachine;
+        /// <summary>
+        /// Gets or sets the selected machine.
+        /// </summary>
+        public MachineModel SelectedMachine
+        {
+            get { return _selectedMachine; }
+            set
+            {
+                if (value != null && _selectedMachine != value)
+                {
+                    _selectedMachine = value;
+                    SelectedMachineChanged();
+                    RaisePropertyChangedAuto();
+                    InvalidateRelayCommands();
+                }
+            }
+        }
+
+        private ObservableCollection<MachineModel> _machines;
+        /// <summary>
+        /// Gets or sets the Machines.
+        /// </summary>
+        public ObservableCollection<MachineModel> Machines
+        {
+            get
+            {
+                return _machines;
+            }
+
+            set
+            {
+                _machines = value; RaisePropertyChanged(nameof(Machines));
+            }
+
+        }
+
+        #endregion
+
+        #region commands
+
+        public RelayCommand SaveCommand { get; set; }
+
+        public RelayCommand ManageRmlExtensionCommand { get; set; }
+
+        public RelayCommand BackToThreadExtensionViewsCommand { get; set; }
+
+        private async void BackToThreadExtensionViews(object obj)
+        {
+            View.NavigateTo(RMLExtensionNavigationView.RMLExtensionsView);
+            await LoadRmlExtentions();
+        }
+
+        public RelayCommand AddManufacturerItemCommand { get; set;}
+        public RelayCommand EditManufacturerItemCommand { get; set; }
+        public RelayCommand DeleteManufacturerItemCommand { get; set; }
+
+        public RelayCommand AddBrandItemCommand { get; set; }
+        public RelayCommand EditBrandItemCommand { get; set; }
+        public RelayCommand DeleteBrandItemCommand { get; set; }
+
+        public RelayCommand AddEndUseItemCommand { get; set; }
+        public RelayCommand EditEndUseItemCommand { get; set; }
+        public RelayCommand DeleteEndUseItemCommand { get; set; }
+
+        public RelayCommand AddApplicationItemCommand { get; set; }
+        public RelayCommand EditApplicationItemCommand { get; set; }
+        public RelayCommand DeleteApplicationItemCommand { get; set; }
+
+        public RelayCommand AddIndustrySectorItemCommand { get; set; }
+        public RelayCommand EditIndustrySectorItemCommand { get; set; }
+        public RelayCommand DeleteIndustrySectorItemCommand { get; set; }
+
+        public RelayCommand AddMaterialItemCommand { get; set; }
+        public RelayCommand EditMaterialItemCommand { get; set; }
+        public RelayCommand DeleteMaterialItemCommand { get; set; }
+
+        public RelayCommand AddYarnTypeItemCommand { get; set; }
+        public RelayCommand EditYarnTypeItemCommand { get; set; }
+        public RelayCommand DeleteYarnTypeItemCommand { get; set; }
+
+        public RelayCommand AddSubFamilyItemCommand { get; set; }
+        public RelayCommand EditSubFamilyItemCommand { get; set; }
+        public RelayCommand DeleteSubFamilyItemCommand { get; set; }
+
+        public RelayCommand AddFamilyItemCommand { get; set; }
+        public RelayCommand EditFamilyItemCommand { get; set; }
+        public RelayCommand DeleteFamilyItemCommand { get; set; }
+
+        public RelayCommand AddGroupItemCommand { get; set; }
+        public RelayCommand EditGroupItemCommand { get; set; }
+        public RelayCommand DeleteGroupItemCommand { get; set; }
+
+        public RelayCommand AddTexturingItemCommand { get; set; }
+        public RelayCommand EditTexturingItemCommand { get; set; }
+        public RelayCommand DeleteTexturingItemCommand { get; set; }
+
+        public RelayCommand AddGeometryItemCommand { get; set; }
+        public RelayCommand EditGeometryItemCommand { get; set; }
+        public RelayCommand DeleteGeometryItemCommand { get; set; }
+
+        public RelayCommand AddYarnWhiteShadeItemCommand { get; set; }
+        public RelayCommand EditYarnWhiteShadeItemCommand { get; set; }
+        public RelayCommand DeleteYarnWhiteShadeItemCommand { get; set; }
+
+        public RelayCommand AddGlossLevelItemCommand { get; set; }
+        public RelayCommand EditGlossLevelItemCommand { get; set; }
+        public RelayCommand DeleteGlossLevelItemCommand { get; set; }
+        
+        #endregion
+
+        #region Command Functions
+
+        private async void AddManufacturerItem(object obj)
+        {
+            AddItemDialogVM vm = ViewModelLocator.AddItemDialogVM;
+            vm.Name = "";
+
+            _notification.ShowModalDialog<AddItemDialogVM, Views.AddItemDialog>(vm, (x) =>
+            {
+                if (Manufacturers.Any(y => y.ToLower() == vm.Name.ToLower()))
+                {
+                    _notification.ShowError("Manufacturer already exists.");
+                    return;
+                }
+                _active_context.YarnManufacturers.Add(new YarnManufacturer() { Name = vm.Name });
+
+            }, () => { });
+            if(vm.DialogResult)
+            {
+                await _active_context.SaveChangesAsync();
+                Manufacturers = _active_context.YarnManufacturers.Select(z => z.Name).ToList();
+                ActiveRML.Manufacturer = Manufacturers.Where(z=> z == vm.Name).FirstOrDefault();
+            }
+        }
+        
+        private async void EditManufacturerItem(object obj)
+        {
+            AddItemDialogVM vm = ViewModelLocator.AddItemDialogVM;
+            vm.Name = ActiveRML.Manufacturer;
+            bool bChanged = false;
+
+            _notification.ShowModalDialog<AddItemDialogVM, Views.AddItemDialog>(vm, (x) =>
+            {
+                if (ActiveRML.Manufacturer == x.Name)
+                    return;
+                if (Manufacturers.Any(y => y == x.Name))
+                {
+                    _notification.ShowError("Manufacturer already exists.");
+                    return;
+                }
+                var editItem = _active_context.YarnManufacturers.Where(z => z.Name == ActiveRML.Manufacturer).FirstOrDefault();
+                if (editItem != null)
+                {
+                    editItem.Name = x.Name;
+                    ActiveRML.Manufacturer = x.Name;
+                    bChanged = true;
+                }
+            }, () => { });
+            if(bChanged)
+            {
+                await _active_context.SaveChangesAsync();
+                Manufacturers = _active_context.YarnManufacturers.Select(x => x.Name).ToList();
+            }
+                
+        }
+
+        private  bool AddItemToCollection<T>( ObservableCollection<T> collection, DbSet<T> dbColection, ref string name) where T : class
+        {
+            AddItemDialogVM vm = ViewModelLocator.AddItemDialogVM;
+            vm.Name = "";
+
+            PropertyInfo pi = typeof(T).GetProperty("Name");
+            bool returnValue = false;
+            _notification.ShowModalDialog<AddItemDialogVM, Views.AddItemDialog>(vm, (x) =>
+            {
+                if (String.IsNullOrEmpty(x.Name))
+                {
+                    returnValue = false;
+                    return;
+                }
+                if (collection.Any(y => pi.GetValue(y).ToString().ToLower() == x.Name.ToLower()))
+                {
+                    returnValue = false;
+                    _notification.ShowError("The name already exists.");
+                    return;
+                }
+                returnValue = true;
+                T newItem = (T)Activator.CreateInstance(typeof(T), new object[] { });
+                pi.SetValue(newItem, x.Name);
+                dbColection.Add(newItem);
+            }, () => { });
+            name = vm.Name;
+            return returnValue;
+        }
+
+        private bool EditItemCollection<T>(ObservableCollection<T> collection, DbSet<T> dbColection, ref string name) where T : class
+        {
+            AddItemDialogVM vm = ViewModelLocator.AddItemDialogVM;
+            vm.Name = name;
+            string currentName = name;
+
+            PropertyInfo pi = typeof(T).GetProperty("Name");
+            bool returnValue = false;
+            _notification.ShowModalDialog<AddItemDialogVM, Views.AddItemDialog>(vm, (x) =>
+            {
+                if (String.IsNullOrEmpty(x.Name) || currentName == x.Name)
+                {
+                    returnValue = false;
+                    return;
+                }
+                
+                if (collection.Any(y => pi.GetValue(y).ToString() == x.Name))
+                {
+                    returnValue = false;
+                    _notification.ShowError("The name already exists.");
+                    return;
+                }
+                returnValue = true;
+            }, () => { });
+            name = vm.Name;
+            return returnValue;
+        }
+
+       
+        private async void AddBrandItem(object obj)
+        {
+            string newName = "";
+            if( AddItemToCollection( Brands, _active_context.YarnBrands, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                Brands = _active_context.YarnBrands.ToObservableCollection();
+                ActiveRMLExtension.YarnBrand = Brands.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        
+        private async void EditBrandItem(object obj)
+        {
+            string newName = ActiveRMLExtension.YarnBrand.Name;
+            if (EditItemCollection(Brands, _active_context.YarnBrands, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnBrand.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+
+        private async void AddEndUseItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(EndUse, _active_context.MediaPurposes, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                EndUse = _active_context.MediaPurposes.ToObservableCollection();
+                ActiveRML.MediaPurpose = EndUse.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditEndUseItem(object ob)
+        {
+            string newName = ActiveRML.MediaPurpose.Name;
+            if (EditItemCollection(EndUse, _active_context.MediaPurposes, ref newName))
+            {
+                ActiveRML.LastUpdated = DateTime.UtcNow;
+                ActiveRML.MediaPurpose.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+       
+        private async void AddApplicationItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(Applications, _active_context.YarnApplications, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                Applications = _active_context.YarnApplications.ToObservableCollection();
+                ActiveRMLExtension.YarnApplication = Applications.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditApplicationItem(object ob)
+        {
+            string newName = ActiveRMLExtension.YarnApplication.Name;
+            if (EditItemCollection(Applications, _active_context.YarnApplications, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnApplication.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+       
+        private async void AddIndustrySectorItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(IndustrySector, _active_context.YarnIndustrysectors, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                IndustrySector = _active_context.YarnIndustrysectors.ToObservableCollection();
+                ActiveRMLExtension.YarnIndustrysector = IndustrySector.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditIndustrySectorItem(object ob)
+        {
+            string newName = ActiveRMLExtension.YarnIndustrysector.Name;
+            if (EditItemCollection(IndustrySector, _active_context.YarnIndustrysectors, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnIndustrysector.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+        
+        private async void AddMaterialItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(Materials, _active_context.MediaMaterials, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                Materials = _active_context.MediaMaterials.ToObservableCollection();
+                ActiveRML.MediaMaterial = Materials.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditMaterialItem(object ob)
+        {
+            string newName = ActiveRML.MediaMaterial.Name;
+            if (EditItemCollection(Materials, _active_context.MediaMaterials, ref newName))
+            {
+                ActiveRML.LastUpdated = DateTime.UtcNow;
+                ActiveRML.MediaMaterial.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+       
+        private async void AddYarnTypeItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(YarnTypes, _active_context.YarnTypes, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                YarnTypes = _active_context.YarnTypes.ToObservableCollection();
+                ActiveRMLExtension.YarnType = YarnTypes.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditYarnTypeItem(object ob)
+        {
+            string newName = ActiveRMLExtension.YarnType.Name;
+            if (EditItemCollection(YarnTypes, _active_context.YarnTypes, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnType.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+       
+        private async void AddSubFamilyItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(SubFamilies, _active_context.YarnSubFamilies, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                SubFamilies = _active_context.YarnSubFamilies.ToObservableCollection();
+                ActiveRMLExtension.YarnSubFamily = SubFamilies.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditSubFamilyItem(object ob)
+        {
+            string newName = ActiveRMLExtension.YarnSubFamily.Name;
+            if (EditItemCollection(SubFamilies, _active_context.YarnSubFamilies, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnSubFamily.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+      
+        private async void AddFamilyItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(Family, _active_context.YarnFamilies, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                Family = _active_context.YarnFamilies.ToObservableCollection();
+                ActiveRMLExtension.YarnFamily = Family.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditFamilyItem(object ob)
+        {
+            string newName = ActiveRMLExtension.YarnFamily.Name;
+            if (EditItemCollection(Family, _active_context.YarnFamilies, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnFamily.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+       
+        private async void AddGroupItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(Group, _active_context.YarnGroups, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                Group = _active_context.YarnGroups.ToObservableCollection();
+                ActiveRMLExtension.YarnGroup = Group.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditGroupItem(object ob)
+        {
+            string newName = ActiveRMLExtension.YarnGroup.Name;
+            if (EditItemCollection(Group, _active_context.YarnGroups, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnGroup.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+       
+        private async void AddTexturingItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(Texturing, _active_context.YarnTexturings, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                Texturing = _active_context.YarnTexturings.ToObservableCollection();
+                ActiveRMLExtension.YarnTexturing = Texturing.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditTexturingItem(object ob)
+        {
+            string newName = ActiveRMLExtension.YarnTexturing.Name;
+            if (EditItemCollection(Texturing, _active_context.YarnTexturings, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnTexturing.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+       
+        private async void AddGeometryItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(Geometry, _active_context.FiberShapes, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                Geometry = _active_context.FiberShapes.ToObservableCollection();
+                ActiveRML.FiberShape = Geometry.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditGeometryItem(object ob)
+        {
+            string newName = ActiveRML.FiberShape.Name;
+            if (EditItemCollection(Geometry, _active_context.FiberShapes, ref newName))
+            {
+                ActiveRML.LastUpdated = DateTime.UtcNow;
+                ActiveRML.FiberShape.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+       
+        private async void AddYarnWhiteShadeItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(YarnWhiteShade, _active_context.YarnWhiteShades, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                YarnWhiteShade = _active_context.YarnWhiteShades.ToObservableCollection();
+                ActiveRMLExtension.YarnWhiteShade = YarnWhiteShade.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditYarnWhiteShadeItem(object ob)
+        {
+            string newName = ActiveRMLExtension.YarnWhiteShade.Name;
+            if (EditItemCollection(YarnWhiteShade, _active_context.YarnWhiteShades, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnWhiteShade.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+       
+        private async void AddGlossLevelItem(object ob)
+        {
+            string newName = "";
+            if (AddItemToCollection(GlossLevel, _active_context.YarnGlossLevels, ref newName))
+            {
+                await _active_context.SaveChangesAsync();
+                GlossLevel = _active_context.YarnGlossLevels.ToObservableCollection();
+                ActiveRMLExtension.YarnGlossLevel = GlossLevel.FirstOrDefault(b => b.Name == newName);
+            }
+        }
+        private async void EditGlossLevelItem(object ob)
+        {
+            string newName = ActiveRMLExtension.YarnGlossLevel.Name;
+            if (EditItemCollection(GlossLevel, _active_context.YarnGlossLevels, ref newName))
+            {
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                ActiveRMLExtension.YarnGlossLevel.Name = newName;
+                await _active_context.SaveChangesAsync();
+            }
+        }
+        
+        #endregion
+
+
+        public MainViewVM(INotificationProvider notificationProvider, IAuthenticationProvider authentication, IActionLogManager actionLogManager)
+        {
+            _notification = notificationProvider;
+            _authentication = authentication;
+            _actionLogManager = actionLogManager;
+
+            BackToThreadExtensionViewsCommand = new RelayCommand(BackToThreadExtensionViews, () => IsFree);
+            SaveCommand = new RelayCommand(Save, () => IsFree);
+            ManageRmlExtensionCommand = new RelayCommand(() => LoadActiveRMLExtension(SelectedRMLExtension.Guid), () => SelectedRMLExtension != null);
+
+            
+            AddManufacturerItemCommand = new RelayCommand(AddManufacturerItem);
+            EditManufacturerItemCommand = new RelayCommand(EditManufacturerItem, () => ActiveRML.Manufacturer != "");
+
+            AddBrandItemCommand = new RelayCommand(AddBrandItem);
+            EditBrandItemCommand = new RelayCommand(EditBrandItem, () => ActiveRMLExtension.YarnBrand != null);
+            
+            AddEndUseItemCommand = new RelayCommand(AddEndUseItem);
+            EditEndUseItemCommand = new RelayCommand(EditEndUseItem);
+            
+            AddApplicationItemCommand = new RelayCommand(AddApplicationItem);
+            EditApplicationItemCommand = new RelayCommand(EditApplicationItem);
+            
+            AddIndustrySectorItemCommand = new RelayCommand(AddIndustrySectorItem);
+            EditIndustrySectorItemCommand = new RelayCommand(EditIndustrySectorItem);
+            
+            AddMaterialItemCommand = new RelayCommand(AddMaterialItem);
+            EditMaterialItemCommand = new RelayCommand(EditMaterialItem);
+            
+            AddYarnTypeItemCommand = new RelayCommand(AddYarnTypeItem);
+            EditYarnTypeItemCommand = new RelayCommand(EditYarnTypeItem);
+            
+            AddSubFamilyItemCommand = new RelayCommand(AddSubFamilyItem);
+            EditSubFamilyItemCommand = new RelayCommand(EditSubFamilyItem);
+           
+            AddFamilyItemCommand = new RelayCommand(AddFamilyItem);
+            EditFamilyItemCommand = new RelayCommand(EditFamilyItem);
+            
+            AddGroupItemCommand = new RelayCommand(AddGroupItem);
+            EditGroupItemCommand = new RelayCommand(EditGroupItem);
+            
+            AddTexturingItemCommand = new RelayCommand(AddTexturingItem);
+            EditTexturingItemCommand = new RelayCommand(EditTexturingItem);
+            
+            AddGeometryItemCommand = new RelayCommand(AddGeometryItem);
+            EditGeometryItemCommand = new RelayCommand(EditGeometryItem);
+            
+            AddYarnWhiteShadeItemCommand = new RelayCommand(AddYarnWhiteShadeItem);
+            EditYarnWhiteShadeItemCommand = new RelayCommand(EditYarnWhiteShadeItem);
+           
+            AddGlossLevelItemCommand = new RelayCommand(AddGlossLevelItem);
+            EditGlossLevelItemCommand = new RelayCommand(EditGlossLevelItem);
+           
+        }
+
+        
+    public override void OnApplicationReady()
+        {
+        }
+        
+
+        #region Loading
+
+        private async Task LoadRmlExtentions()
+        {
+            var filter = Filter.ToStringOrEmpty().ToLower();
+
+            try
+            {
+                IsFree = false;
+
+                using (_notification.PushTaskItem("Loading RmlExtentions..."))
+                {
+                    if (_rmlExtentions_context != null) _rmlExtentions_context.Dispose();
+
+                    _rmlExtentions_context = ObservablesContext.CreateDefault();
+
+                    Brands = _rmlExtentions_context.YarnBrands.ToObservableCollection();
+                    _allUsers = await _rmlExtentions_context.Users.Include(x => x.Contact).ToListAsync();
+                    var q = (from c in _rmlExtentions_context.Rmls.Where(x => x.Name.ToLower().Contains(filter))
+                             join p in _rmlExtentions_context.RmlsExtensions on c.Guid equals p.RmlsGuid into ps
+                             from p in ps.DefaultIfEmpty()
+                             select new { RML = c,   RMLExtesion = p  }).Distinct().ToList().DistinctBy(x => x.RML.Guid)
+                             .Select(x => new RmlExtensionModel()
+                             {
+                                 RMLGuid = x.RML.Guid,
+                                 Guid = x.RMLExtesion == null? null : x.RMLExtesion.Guid,
+                                 Name = x.RML.Name,
+                                 Manufacturer = x.RML.Manufacturer,
+                                 Brand = x.RMLExtesion == null ?  "" : (Brands.Where( y => y.Guid == x.RMLExtesion.YarnBrandGuid).Select( z => z.Name).FirstOrDefault()),
+                                 LinearDensity = (int) x.RML.FiberSize,
+                                 CreatedBy = x.RMLExtesion == null ? "" : _allUsers.SingleOrDefault(y => y.Guid == x.RMLExtesion.UsersGuid).Contact.FullName,
+                                 Created = x.RMLExtesion == null ? DateTime.Now : x.RMLExtesion.Created,
+                                 LastUpdated = x.RMLExtesion == null ? DateTime.Now : x.RMLExtesion.LastUpdated,
+                                 Status = x.RMLExtesion == null ? RMLExtensionStatus.New : x.RMLExtesion.RMLStatus
+                             }).ToList();
+                    RmlExtensions = q;
+                   // RmlExtCollectionView = CollectionViewSource.GetDefaultView(RmlExtensions);
+                   // RmlExtCollectionView.SortDescriptions.Add(new SortDescription(nameof(Rml.LastUpdated), ListSortDirection.Ascending));
+
+                    //RmlExtCollectionView.Filter = (rml) =>
+                    //{
+                    //    RmlExtensionModel r = rml as RmlExtensionModel;
+                    //    return String.IsNullOrWhiteSpace(Filter)
+                    //    || r.Name.ToLower().Contains(Filter.ToLower());
+                    //};
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, $"Error loading RMLExtensions.\n{ex.FlattenMessage()}");
+            }
+            finally
+            {
+                IsFree = true;
+            }
+        }
+
+        private void LoadRmlProperties()
+        {
+            Applications = _active_context.YarnApplications.ToObservableCollection();
+            Brands = _active_context.YarnBrands.ToObservableCollection();
+            YarnWhiteShade = _active_context.YarnWhiteShades.ToObservableCollection();
+            EndUse = _active_context.MediaPurposes.ToObservableCollection();
+            Family = _active_context.YarnFamilies.ToObservableCollection();
+            Geometry = _active_context.FiberShapes.ToObservableCollection();
+            GlossLevel = _active_context.YarnGlossLevels.ToObservableCollection();
+            Group = _active_context.YarnGroups.ToObservableCollection();
+            //Manufacturer = _active_context.YarnManufacturers.ToObservableCollection();
+            Manufacturers = _active_context.YarnManufacturers.Select(x => x.Name).ToList();
+            Units = _active_context.LinearMassDensityUnits.ToObservableCollection();
+            Materials = _active_context.MediaMaterials.ToObservableCollection();
+            SubFamilies = _active_context.YarnSubFamilies.ToObservableCollection();
+            Texturing = _active_context.YarnTexturings.ToObservableCollection();
+            YarnTypes = _active_context.YarnTypes.ToObservableCollection();
+            IndustrySector = _active_context.YarnIndustrysectors.ToObservableCollection();
+            Machines = ObservablesStaticCollections.Instance.Machines.Select(x => new MachineModel()
+            {
+                Guid = x.Guid,
+                Name = x.Name,
+                SerialNumber = x.SerialNumber
+            }).ToObservableCollection();
+
+        }
+        
+        private RmlsExtension GetNewRMLsExtension( string RML_Guid)
+        {
+            RmlsExtension rml_extention = new RmlsExtension();
+            rml_extention.Created = DateTime.UtcNow;
+            rml_extention.RmlsGuid = RML_Guid;
+            rml_extention.UsersGuid = _authentication.CurrentUser.Guid;
+            //rml_extention.YarnManufacturer = Manufacturer.FirstOrDefault();
+            rml_extention.YarnBrand = Brands.FirstOrDefault();
+            rml_extention.Country = null;
+            //rml_extention.YarnEndUse = EndUse.FirstOrDefault();
+            rml_extention.YarnApplication = Applications.FirstOrDefault();
+            rml_extention.YarnIndustrysector = IndustrySector.FirstOrDefault();
+
+            //rml_extention.YarnMaterial = Materials.FirstOrDefault();
+            rml_extention.YarnType = YarnTypes.FirstOrDefault();
+            rml_extention.YarnSubFamily = SubFamilies.FirstOrDefault();
+            rml_extention.YarnFamily = Family.FirstOrDefault();
+            rml_extention.YarnGroup = Group.FirstOrDefault();
+            rml_extention.YarnTexturing = Texturing.FirstOrDefault();
+            rml_extention.YarnWhiteShade = YarnWhiteShade.FirstOrDefault();
+            rml_extention.YarnGlossLevel = GlossLevel.FirstOrDefault();
+            rml_extention.TwistTpm = 0;
+            rml_extention.YarnTwistDirections = TwistDirections.Unknown;
+            rml_extention.MinElongation = 0.0;
+            rml_extention.MaxElongation = 100.0;
+            rml_extention.MinMaxForceN = 0.0;
+            rml_extention.MaxMaxForceN = 100.0;
+            rml_extention.MinElasticity = 0.0;
+            rml_extention.MaxElasticity = 100.0;
+            rml_extention.MinTenacity = 0.0;
+            rml_extention.MaxTenacity = 100.0;
+            rml_extention.Finishing = "Lubrication";
+            rml_extention.RMLStatus = RMLExtensionStatus.New;
+
+            return rml_extention;
+        }
+        
+        private async void LoadActiveRMLExtension(String guid)
+        {
+            using (_notification.PushTaskItem("Loading RML Extension..."))
+            {
+                try
+                {
+                    IsFree = false;
+
+                    if (_active_context != null)
+                    {
+                        _active_context.Dispose();
+                    }
+
+                    _active_context = ObservablesContext.CreateDefault();
+                    LoadRmlProperties();
+
+                    if (guid == null)
+                    {
+                        RmlsExtension rml_extention = GetNewRMLsExtension(SelectedRMLExtension.RMLGuid);
+                        _active_context.RmlsExtensions.Add(rml_extention);
+                        await _active_context.SaveChangesAsync();
+                        guid = rml_extention.Guid;
+                    }
+
+                    ActiveRMLExtension = await new RmlExtensionsBuilder(_active_context)
+                                            .Set(guid)
+                                            .WithUser()
+                                            .BuildAsync();
+
+                    ActiveRML =  new RmlBuilder(_active_context)
+                        .Set(SelectedRMLExtension.RMLGuid)
+                        .Build();
+                    
+                    var machineIdsHasTest = (from c in _active_context.ColorProcessParameters.Where(x => x.RmlsExtensionsGuid == guid)
+                             select new { MichineGUID = c.MachineGuid }).
+                             Union (from p in _active_context.RmlExtensionTestResults.Where(x => x.RmlsExtensionsGuid == guid)
+                             select new { MichineGUID = p.MachineGuid }).DistinctBy(x => x).ToList();
+
+                    if(machineIdsHasTest.Count > 0)
+                    {
+                        var MachineGuid = machineIdsHasTest.First().MichineGUID;
+                        Machines.Where(x => machineIdsHasTest.Any(y => y.MichineGUID == x.Guid)).ToList().ForEach(x => x.HasRMLTest = true);
+                        SelectedMachine = Machines.First(x => x.Guid == MachineGuid);
+                    }
+                    else
+                    {
+                        var settings = SettingsManager.Default.GetOrCreate<MachineStudioSettings>();
+                        if(settings.LastVirtualMachineSerialNumber != null)
+                        {
+                            SelectedMachine = Machines.SingleOrDefault(x => x.SerialNumber == settings.LastVirtualMachineSerialNumber);
+                        }
+                        else
+                        {
+                            SelectedMachine = Machines.First();
+                        }
+                    }
+                    
+                    ColorParametersVewVM = new ColorParametersVewVM(_notification, _actionLogManager);
+                    ColorParametersVewVM.RMLExtemtionGUID = guid;
+                    ColorParametersVewVM.SelectedMachineGUID = SelectedMachine != null ? SelectedMachine.Guid : null ;
+                    ColorParametersVewVM.RMLGUID = ActiveRML.Guid;
+
+                    TestResultsViewVM = new TestResultsViewVM(_notification, _actionLogManager);
+                    TestResultsViewVM.RMLExtemtionGUID = guid;
+                    TestResultsViewVM.RMLGUID = ActiveRML.Guid;
+                    TestResultsViewVM.SelectedMachineGUID = SelectedMachine != null ? SelectedMachine.Guid : null;
+                    TestResultsViewVM.ThreadName = ActiveRML.Manufacturer;
+                    
+                    if (ActiveRMLExtension.RMLStatus == RMLExtensionStatus.New)
+                    {
+                        ColorParametersVewVM.SaveColorParameters -= UpdateStatus;
+                        ColorParametersVewVM.SaveColorParameters += UpdateStatus;
+                        TestResultsViewVM.SaveTestResults -= UpdateStatus;
+                        TestResultsViewVM.SaveTestResults += UpdateStatus;
+                    }
+
+                    View.NavigateTo(RMLExtensionNavigationView.RMLExtentionView);
+
+                    InvalidateRelayCommands();
+
+                    IsFree = true;
+                }
+                catch (Exception ex)
+                {
+                    //LogManager.Log($"Error loading RML '{ActiveRML.Name}'...");
+                    _notification.ShowError($"Error loading the selected thread.\n{ex.FlattenMessage()}");
+                }
+                finally
+                {
+                    IsFree = true;
+                }
+            }
+        }
+        
+        private async void RefreshView(String guid, String rmlGuid)
+        {
+            try
+            {
+                IsFree = false;
+                
+                LoadRmlProperties();
+                ActiveRML = ActiveRML = await new RmlBuilder(_active_context)
+                        .Set(rmlGuid)
+                        .BuildAsync();
+                ActiveRMLExtension = await new RmlExtensionsBuilder(_active_context)
+                    .Set(guid)
+                    .WithUser()
+                    .BuildAsync();
+                
+                InvalidateRelayCommands();
+
+                IsFree = true;
+            }
+            catch (Exception ex)
+            {
+                //LogManager.Log($"Error loading RML '{ActiveRML.Name}'...");
+                _notification.ShowError($"Error refresh after save the selected thread.\n{ex.FlattenMessage()}");
+            }
+            finally
+            {
+                IsFree = true;
+            }
+        }
+
+        #endregion
+
+        #region event handlers
+
+        private async void UpdateStatus(object sender, EventArgs e)
+        {
+            IsFree = false;
+
+            try
+            {
+                ColorParametersVewVM.SaveColorParameters -= UpdateStatus;
+                TestResultsViewVM.SaveTestResults -= UpdateStatus;
+                ActiveRMLExtension.RMLStatus = RMLExtensionStatus.InProgress;
+                ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+
+                await _active_context.SaveChangesAsync();
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, $"Error saving Status of RML Extension");
+                _notification.ShowError($"An error occurred while trying to save status of the current RML Extension.\n{ex.FlattenMessage()}");
+            }
+            finally
+            {
+                IsFree = true;
+            }
+        }
+
+        private void SelectedMachineChanged()
+        {
+           if(ColorParametersVewVM != null)
+           {
+                ColorParametersVewVM.SelectedMachineGUID = SelectedMachine.Guid;
+           }
+        }
+
+        #endregion
+
+        #region Save
+
+        /// <summary>
+        /// Saves this instance.
+        /// </summary>
+        private async void Save()
+        {
+            IsFree = false;
+
+            try
+            {
+                using (_notification.PushTaskItem("Saving RML Extension..."))
+                {
+                    if(ActiveRMLExtension.RMLStatus == RMLExtensionStatus.New)
+                    {
+                        ActiveRMLExtension.RMLStatus = RMLExtensionStatus.InProgress;
+                        ColorParametersVewVM.SaveColorParameters -= UpdateStatus;
+                        TestResultsViewVM.SaveTestResults -= UpdateStatus;
+                    }
+
+                    ActiveRMLExtension.LastUpdated = DateTime.UtcNow;
+                    ActiveRML.LastUpdated = DateTime.UtcNow;
+                    
+                    await _active_context.SaveChangesAsync();
+
+                    // _actionLogManager.InsertLog(BL.Enumerations.ActionLogType.RmlSaved, _authentication.CurrentUser, _rmlBeforeSave.Name, _rmlBeforeSave, rmlAfter, "RML saved using Machine Studio.");
+                    
+                    RefreshView(ActiveRMLExtension.Guid, ActiveRML.Guid);
+                }
+            }
+            catch (Exception ex)
+            {
+                LogManager.Log(ex, $"Error saving RML Extension of RML{ActiveRML.Name}");
+                _notification.ShowError($"An error occurred while trying to save the current RML Extension.\n{ex.FlattenMessage()}");
+            }
+            finally
+            {
+                IsFree = true;
+            }
+        }
+
+        #endregion
+    }
+}