Merge branch 'master' of https://twinetfs.visualstudio.com/_git/Tango

1 files changed, 370 insertions, 0 deletions

diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.UsersAndRoles/ViewModels/MainViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.UsersAndRoles/ViewModels/MainViewVM.cs
new file mode 100644
index 000000000..7d82cbbbc
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.UsersAndRoles/ViewModels/MainViewVM.cs
@@ -0,0 +1,370 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+using Tango.BL;
+using Tango.BL.Entities;
+using Tango.Core.Commands;
+using Tango.MachineStudio.Common.Notifications;
+using Tango.MachineStudio.UsersAndRoles.Navigation;
+using Tango.MachineStudio.UsersAndRoles.Providers;
+using Tango.SharedUI;
+
+namespace Tango.MachineStudio.UsersAndRoles.ViewModels
+{
+    public class MainViewVM : ViewModel
+    {
+        private ObservablesContext _organizationsContext;
+        private ObservablesContext _manageContext;
+        private ObservablesContext _userContext;
+        private UsersAndRolesNavigationManager _navigation;
+        private INotificationProvider _notification;
+
+        private ObservableCollection<Organization> _organizations;
+        public ObservableCollection<Organization> Organizations
+        {
+            get { return _organizations; }
+            set { _organizations = value; RaisePropertyChangedAuto(); }
+        }
+
+        private Organization _selectedOrganization;
+        public Organization SelectedOrganization
+        {
+            get { return _selectedOrganization; }
+            set { _selectedOrganization = value; RaisePropertyChangedAuto(); }
+        }
+
+        private Organization _managedOrganization;
+        public Organization ManagedOrganization
+        {
+            get { return _managedOrganization; }
+            set { _managedOrganization = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<Role> _roles;
+        public ObservableCollection<Role> Roles
+        {
+            get { return _roles; }
+            set { _roles = value; RaisePropertyChangedAuto(); }
+        }
+
+        private ObservableCollection<Role> _managedUserRoles;
+        public ObservableCollection<Role> ManagedUserRoles
+        {
+            get { return _managedUserRoles; }
+            set { _managedUserRoles = value; RaisePropertyChangedAuto(); }
+        }
+
+        private User _selectedUser;
+        public User SelectedUser
+        {
+            get { return _selectedUser; }
+            set { _selectedUser = value; RaisePropertyChangedAuto(); }
+        }
+
+        private User _managedUser;
+        public User ManagedUser
+        {
+            get { return _managedUser; }
+            set { _managedUser = value; RaisePropertyChangedAuto(); }
+        }
+
+        private Place _selectedUserPlace;
+        public Place SelectedUserPlace
+        {
+            get { return _selectedUserPlace; }
+            set
+            {
+                _selectedUserPlace = value;
+
+                if (_selectedUserPlace != null && _selectedUserPlace.Address != null)
+                {
+                    SetUserPlace(value);
+                }
+            }
+        }
+
+        private Place _selectedOrganizationPlace;
+        public Place SelectedOrganizationPlace
+        {
+            get { return _selectedOrganizationPlace; }
+            set
+            {
+                _selectedOrganizationPlace = value;
+
+                if (_selectedOrganizationPlace != null && _selectedOrganizationPlace.Address != null)
+                {
+                    SetOrganizationPlace(value);
+                }
+            }
+        }
+
+        public RelayCommand ManageOrganizationCommand { get; set; }
+
+        public RelayCommand BackToOrganizationsCommand { get; set; }
+
+        public RelayCommand ManageUserCommand { get; set; }
+
+        public RelayCommand SaveOrganizationCommand { get; set; }
+
+        public RelayCommand AddOrganizationCommand { get; set; }
+
+        public RelayCommand RemoveOrganizationCommand { get; set; }
+
+        public RelayCommand BackToManagedOrganizationCommand { get; set; }
+
+        public RelayCommand<Role> RemoveRoleCommand { get; set; }
+
+        public RelayCommand SaveManagedUserCommand { get; set; }
+
+        public RelayCommand AddUserCommand { get; set; }
+
+        public RelayCommand RemoveUserCommand { get; set; }
+
+        public MainViewVM(UsersAndRolesNavigationManager navigation, INotificationProvider notification)
+        {
+            _navigation = navigation;
+            _notification = notification;
+
+            LoadOrganizations();
+
+            ManageOrganizationCommand = new RelayCommand(LoadSelectedOrganization, () => SelectedOrganization != null);
+            BackToOrganizationsCommand = new RelayCommand(BackToOrganizations);
+            ManageUserCommand = new RelayCommand(LoadSelectedUser, () => SelectedUser != null);
+            SaveOrganizationCommand = new RelayCommand(SaveOrganization);
+            AddOrganizationCommand = new RelayCommand(AddOrganization);
+            RemoveOrganizationCommand = new RelayCommand(RemoveOrganization, () => SelectedOrganization != null);
+            BackToManagedOrganizationCommand = new RelayCommand(BackToManagedOrganization);
+            RemoveRoleCommand = new RelayCommand<Role>(RemoveUserRole);
+            SaveManagedUserCommand = new RelayCommand(SaveManagedUser);
+            AddUserCommand = new RelayCommand(AddNewUser);
+            RemoveUserCommand = new RelayCommand(RemoveSelectedUser, () => SelectedUser != null);
+        }
+
+        private async void AddOrganization()
+        {
+            String name = _notification.ShowTextInput("Enter organization name", "Name");
+
+            if (!String.IsNullOrWhiteSpace(name))
+            {
+                using (_notification.PushTaskItem("Adding new organization..."))
+                {
+                    Organization org = new Organization();
+                    org.Name = name;
+                    org.Address = new Address();
+                    org.Contact = new Contact();
+                    _organizationsContext.Organizations.Add(org);
+                    await org.SaveAsync(_organizationsContext);
+                    Organizations = _organizationsContext.Organizations.ToObservableCollection();
+                    SelectedOrganization = org;
+                    LoadSelectedOrganization();
+                }
+            }
+        }
+
+        private async void RemoveOrganization()
+        {
+            if (_notification.ShowQuestion("Are you sure you want to remove " + SelectedOrganization.Name + " organization?"))
+            {
+                using (_notification.PushTaskItem("Removing organization..."))
+                {
+                    await SelectedOrganization.DeleteCascadeAsync(_organizationsContext);
+                    LoadOrganizations();
+                }
+            }
+        }
+
+        private async void SaveOrganization()
+        {
+            using (_notification.PushTaskItem("Saving organization address and contact..."))
+            {
+                await ManagedOrganization.SaveAsync(_manageContext);
+                LoadOrganizations();
+                SelectedOrganization = Organizations.SingleOrDefault(x => x.Guid == ManagedOrganization.Guid);
+            }
+        }
+
+        private void LoadSelectedUser()
+        {
+            using (_notification.PushTaskItem("Loading user details..."))
+            {
+                Task.Factory.StartNew(() =>
+                {
+                    _userContext = ObservablesContext.CreateDefault();
+                    Roles = _userContext.Roles.ToObservableCollection();
+                    ManagedUser = _userContext.Users.SingleOrDefault(x => x.Guid == SelectedUser.Guid);
+                    ManagedUserRoles = ManagedUser.Roles.ToObservableCollection();
+
+                    InvokeUI(() => _navigation.NavigateTo(UsersAndRolesNavigationView.UserManagementView));
+                });
+            }
+        }
+
+        private void BackToOrganizations()
+        {
+            _navigation.NavigateTo(UsersAndRolesNavigationView.OrganizationSelectionView);
+        }
+
+        private void BackToManagedOrganization()
+        {
+            _navigation.NavigateTo(UsersAndRolesNavigationView.OrganizationManagementView);
+        }
+
+        private void RemoveUserRole(Role role)
+        {
+            ManagedUserRoles.Remove(role);
+
+            foreach (var userRole in ManagedUser.UsersRoles.Where(x => x.Role == role).ToList())
+            {
+                userRole.DefferedDelete(_userContext);
+            }
+        }
+
+        private async void SaveManagedUser()
+        {
+            try
+            {
+                ManagedUser.Validate(_userContext);
+            }
+            catch (Exception ex)
+            {
+                _notification.ShowError(ex.Message);
+                return;
+            }
+
+            using (_notification.PushTaskItem("Saving user details..."))
+            {
+                await ManagedUser.SaveAsync(_userContext);
+                LoadSelectedOrganization();
+            }
+        }
+
+        private void LoadSelectedOrganization()
+        {
+            using (_notification.PushTaskItem("Loading organization..."))
+            {
+                Task.Factory.StartNew(() =>
+                {
+                    _manageContext = ObservablesContext.CreateDefault();
+                    ManagedOrganization = _manageContext.Organizations.SingleOrDefault(x => x.Guid == SelectedOrganization.Guid);
+
+                    InvokeUI(() => _navigation.NavigateTo(UsersAndRolesNavigationView.OrganizationManagementView));
+                });
+            }
+        }
+
+        private void LoadOrganizations()
+        {
+            _organizationsContext = ObservablesContext.CreateDefault();
+            _organizationsContext.Configuration.LazyLoadingEnabled = false;
+
+            _organizationsContext.Users.ToList();
+            _organizationsContext.Contacts.ToList();
+            _organizationsContext.Addresses.ToList();
+            _organizationsContext.Machines.ToList();
+
+            Organizations = _organizationsContext.Organizations.ToObservableCollection();
+        }
+
+        public void OnDropRole(Role role)
+        {
+            ManagedUser.UsersRoles.Add(new UsersRole()
+            {
+                Role = role,
+                RoleGuid = role.Guid,
+                User = ManagedUser,
+                UserGuid = ManagedUser.Guid,
+            });
+
+            ManagedUserRoles.Add(role);
+        }
+
+        private async void RemoveSelectedUser()
+        {
+            if (_notification.ShowQuestion("Are you sure you want to remove the selected user?"))
+            {
+                using (_notification.PushTaskItem("Removing user..."))
+                {
+                    await SelectedUser.DeleteCascadeAsync(_manageContext);
+                    LoadSelectedOrganization();
+                }
+            }
+        }
+
+        private async void AddNewUser()
+        {
+            String email = _notification.ShowTextInput("Enter user email", "email");
+
+            if (!String.IsNullOrWhiteSpace(email))
+            {
+                User user = new User();
+                user.Email = email;
+                user.Password = "1111";
+                user.Contact = new Contact()
+                {
+                    FirstName = "Twine",
+                    LastName = "User",
+                    Email = email,
+                };
+
+                user.UsersRoles.Add(new UsersRole()
+                {
+                    User = user,
+                    Role = _manageContext.Roles.SingleOrDefault(x => x.Code == (int)BL.Enumerations.Roles.User)
+                });
+
+                try
+                {
+                    user.Validate(_manageContext);
+                }
+                catch (Exception ex)
+                {
+                    _notification.ShowError(ex.Message);
+                    return;
+                }
+
+                user.Address = new Address();
+
+                ManagedOrganization.Users.Add(user);
+
+                using (_notification.PushTaskItem("Adding new user..."))
+                {
+                    await ManagedOrganization.SaveAsync(_manageContext);
+                    LoadOrganizations();
+                    SelectedOrganization = Organizations.SingleOrDefault(x => x.Guid == ManagedOrganization.Guid);
+                }
+            }
+        }
+
+        private void SetUserPlace(Place place)
+        {
+            ManagedUser.Address.AddressString = place.Address.Road;
+            ManagedUser.Address.City = place.Address.City;
+            ManagedUser.Address.Country = place.Address.Country;
+            ManagedUser.Address.CountryCode = place.Address.CountryCode;
+            ManagedUser.Address.Locality = place.Address.CountryCode;
+            ManagedUser.Address.PostalCode = place.Address.PostalCode;
+            ManagedUser.Address.State = place.Address.State;
+        }
+
+        private void SetOrganizationPlace(Place place)
+        {
+            ManagedOrganization.Address.AddressString = place.Address.Road;
+            ManagedOrganization.Address.City = place.Address.City;
+            ManagedOrganization.Address.Country = place.Address.Country;
+            ManagedOrganization.Address.CountryCode = place.Address.CountryCode;
+            ManagedOrganization.Address.Locality = place.Address.CountryCode;
+            ManagedOrganization.Address.PostalCode = place.Address.PostalCode;
+            ManagedOrganization.Address.State = place.Address.State;
+        }
+
+        protected override void RaisePropertyChangedAuto([CallerMemberName] string caller = null)
+        {
+            base.RaisePropertyChangedAuto(caller);
+            InvalidateRelayCommands();
+        }
+    }
+}