/// <summary>
        /// All steps that represents an asynchronous operation.
        /// </summary>
        /// <param name="stepName">The step's name that should be invoke</param>
        /// <returns>A instance of the <see cref="Task" /> class</returns>
        public override async Task OnStepAsync(object stepName)
        {
            int queueTempID;

            if (this.OnCheckOutChanged != null)
            {
                this.OnCheckOutChanged(false);
            }
            
            this._CurrentEnumStep = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());
            switch (this._CurrentEnumStep)
            {
                case EnumSteps.Start:
                    this.BusyContent = LoadingText;
                    this.IsBusy = true;
                    await Task.WhenAll(
                        this.PopulateAllCollectionsQueuesAsync(),
                        this.GetClientFinancialAsync());
                    await Instance();
                    this.BusyContent = string.Empty;
                    this.IsBusy = false;
                    break;
                case EnumSteps.SelectQueue:
                    this.BusyContent = LoadingText;
                    this.IsBusy = true;
                    this.GridStyle = (Brush)Application.Current.FindResource("GridStyleNotEdit");
                    if (this.SelectedQueue.IsNewQueue == false)
                    {
                        this.SelectedQueue.CollectionQueue = await QueueManagmentFunctions.GetCollectionQueueAsync(this.SelectedQueue.QueueDetailId);
                    }

                    // check if the Client Financial's value of the currently Queue is not assign to default value.
                    if (this.SelectedQueue.CollectionQueue.ClientFinancialsTypeID <= 0)
                    {
                        // assign the default value for ClientFinancialsTypeID.
                        this.SelectedQueue.CollectionQueue.ClientFinancialsTypeID = -1;
                    }

                    LoadAllDetailOnView(SelectedQueue.QueueDetailId);

                    this.SelectedQueue.ClientFinancials = this.ClientFinancials;

                    if (this.OnCollectorsChanged != null)
                    {
                        this.OnCollectorsChanged(CollectionsQueueCollectorsFunctions.QueueList());
                    }

                    this.ActiveViewModel = this;
                    this.SetActionCommandsAsync();

                    if (this.IsCheckedOut)
                    {
                        await this.OnStepAsync(EnumSteps.Edit.ToString());
                    }
                    this.BusyContent = string.Empty;
                    this.IsBusy = false;
                    if (this.SelectedQueue.IsNewQueue == false)
                    {
                        this.RaiseActionsWhenChangeStep(EnumScreen.ColletionQueues, EnumSteps.SelectQueue, this.SelectedQueue.QueueDetailId);
                    }
                    break;
                case EnumSteps.Details:
                    this._IsDetailStepped = true;
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(this._CurrentEnumStep.ToString());
                    }
                    this.OnCheckOutChanged(this.Edit.IsCheckedOut);
                    break;
                case EnumSteps.Collectors:
                    this._IsDetailStepped = false;
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(this._CurrentEnumStep.ToString());
                    }
                    this.OnCheckOutChanged(this.Edit.IsCheckedOut);
                    break;
                case EnumSteps.Add:
                    var newQueue = await QueueManagmentFunctions.AddNewQueueAsync(0);
                    newQueue.ClientFinancials = this.ClientFinancials;

                    await SetSelectedQueueAsync(newQueue);
                    this.RaiseActionsWhenChangeStep(EnumScreen.ColletionQueues, EnumSteps.Add);
                    await this.OnStepAsync(EnumSteps.Edit);
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(EnumSteps.Details.ToString());
                    }
                    if (this.OnCheckOutChanged != null)
                    {
                        this.OnCheckOutChanged(true);
                    }
                    break;
                case EnumSteps.Process:
                    this.BusyContent = LoadingText;
                    this.IsBusy = true;
                    Task task = new Task(ProcessData);
                    task.ContinueWith(async t =>
                    {
                        await this.PopulateAllCollectionsQueuesAsync();
                        this.BusyContent = string.Empty;
                        this.IsBusy = false;
                    });
                    task.Start();
                    break;
                case EnumSteps.Edit:
                    //if (await this.LockAsync() == false)
                    //{
                    //    return;
                    //}
                    this.GridStyle = (Brush)Application.Current.FindResource("GridStyleEdit");
                    this.RaiseActionsWhenChangeStep(EnumScreen.ColletionQueues, EnumSteps.Edit);
                    if (this.isCopy == false)
                    {
                        this.Edit.SelectedQueue = this.SelectedQueue;
                    }

                    if (this.OnCheckOutChanged != null)
                    {
                        this.OnCheckOutChanged(true);
                    }
                    this.Edit.InstanceGUID = this.InstanceGUID;
                    await this.Edit.OnStepAsync(EditQueueViewModel.EnumSteps.Start);
                    break;
                case EnumSteps.CurrentQueue:
                    this.ActiveViewModel = this;
                    await Instance();
                    if (this.OnCollectorsChanged != null)
                    {
                        this.OnCollectorsChanged(CollectionsQueueCollectorsFunctions.QueueList());
                    }
                    this.SetActionCommandsAsync();
                    break;
                case EnumSteps.RefreshQueue:

                    queueTempID = this.SelectedQueue.CollectionQueue.ID;
                    if (null == this.SelectedQueue.ClientFinancials || !this.SelectedQueue.ClientFinancials.Any())
                    {
                        this.SelectedQueue.ClientFinancials = this.ClientFinancials;
                    }

                    await Task.WhenAll(this.PopulateAllCollectionsQueuesAsync());
                    this.SelectedQueue = this.AllQueueManagementDetails.Where(item => item.CollectionQueue.ID == queueTempID).FirstOrDefault();
                    await Instance();
                    break;
                case EnumSteps.Copy:
                    this.isCopy = true;
                    QueueDetailsModel copyQueue = await QueueManagmentFunctions.CopyQueueAsync(this.SelectedQueue);
                    copyQueue.IsNewQueue = true;
                    
                    this.Edit.SelectedQueue = copyQueue;
                    await SetSelectedQueueAsync(copyQueue);
                    this.RaiseActionsWhenChangeStep(EnumScreen.ColletionQueues, EnumSteps.Copy);
                    await this.OnStepAsync(EnumSteps.Edit);
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(EnumSteps.Details.ToString());
                    }
                    break;
            }
            
            this.SetActionCommandsAsync();
            this.OnStepChanged(_CurrentEnumStep.ToString());
        }
        /// <summary>
        /// All steps that represents an asynchronous operation.
        /// </summary>
        /// <param name="stepName">The step's name that should be invoke</param>
        /// <returns>A instance of the <see cref="Task" /> class</returns>
        public override async Task OnStepAsync(object stepName)
        {
            int queueTempID;

            if (this.OnCheckOutChanged != null)
            {
                this.OnCheckOutChanged(false);
            }
            
            this._CurrentEnumStep = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());
            switch (this._CurrentEnumStep)
            {
                case EnumSteps.Start:
                    this.BusyContent = "Please Wait Loading ...";
                    this.IsBusy = true;
                    AvailableCollectorList = new ObservableCollection<Collectors>();
                    await Task.WhenAll(
                        this.PopulateAllCollectionsQueuesAsync(),
                        this.GetClientFinancialAsync());
                    await Instance();
                    if (this.OnCollectorsChanged != null)
                    {
                        this.OnCollectorsChanged(CollectionsQueueCollectorsFunctions.QueueList());
                    }
                    this.BusyContent = string.Empty;
                    this.IsBusy = false;
                    break;
                case EnumSteps.ResetCollectors:
                    if (this.OnCollectorsChanged != null)
                    {
                        this.OnCollectorsChanged(CollectionsQueueCollectorsFunctions.QueueList());
                    }

                    this.ActiveViewModel = this;
                    this.SetActionCommandsAsync();

                    if (this.IsCheckedOut)
                    {
                        await this.OnStepAsync(EnumSteps.Edit.ToString());
                    }
                    break;             
                case EnumSteps.Edit:
                    //if (await this.LockAsync() == false)
                    //{
                    //    return;
                    //}
                    this.RaiseActionsWhenChangeStep(EnumScreen.Collectors, EnumSteps.Edit);
                    if (this.OnCheckOutChanged != null)
                    {
                        this.OnCheckOutChanged(true);
                    }
                    this.Edit.InstanceGUID = this.InstanceGUID;
                    await this.Edit.OnStepAsync(EditQueueViewModel.EnumSteps.Start);
                    break;
                case EnumSteps.RefreshQueue:
                    this.ActiveViewModel = this;
                    await Task.WhenAll(this.PopulateAllCollectionsQueuesAsync());
                    if (this.OnCollectorsChanged != null)
                    {
                        this.OnCollectorsChanged(CollectionsQueueCollectorsFunctions.QueueList());
                    }
                    // await Instance();
                    break;
            }
            
            this.SetActionCommandsAsync();
            this.OnStepChanged(_CurrentEnumStep.ToString());
        }
 /// <summary>
 /// The on step async.
 /// </summary>
 /// <param name="stepName">
 /// The step name.
 /// </param>
 /// <returns>
 /// The <see cref="Task"/>.
 /// </returns>
 public override async Task OnStepAsync(object stepName)
 {
     this._currentEnumStep = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());
     switch (this._currentEnumStep)
     {
         case EnumSteps.Start:
             this.SetBusyAction("Please Wait Loading ...");
             AvailableUsersList = new ObservableCollection<Membership>();
             await Task.WhenAll(this.PopulateAllUsersAsync(), this.PopulateAllGroupsAsync());
             await Instance();
             if (this.OnUsersInGroupChanged != null)
             {
                 this.OnUsersInGroupChanged(this.Groups.ToList(), this.AllUsers.ToList());
             }
             this.ResetBusyAction();
             break;
         case EnumSteps.Edit:
             //if (await this.LockAsync() == false)
             //{
             //    return;
             //}
             
             if (this.OnCheckOutChanged != null)
             {
                 this.OnCheckOutChanged(true);
             }
             this.Edit.InstanceGUID = this.InstanceGUID;
             await this.Edit.OnStepAsync(EditMembershipViewModel.EnumSteps.Start);
             break;
         case EnumSteps.Reset:
             this.ActiveViewModel = this;
             await Instance();
             if (this.OnUsersInGroupChanged != null)
             {
                 this.OnUsersInGroupChanged(this.Groups.ToList(), this.AllUsers.ToList());
             }
             break;
         case EnumSteps.Refresh:
             this.ActiveViewModel = this;
             await Task.WhenAll(this.PopulateAllUsersAsync(), this.PopulateAllGroupsAsync());
             if (this.OnUsersInGroupChanged != null)
             {
                 this.OnUsersInGroupChanged(this.Groups.ToList(), this.AllUsers.ToList());
             }
             if (this.OnCheckOutChanged != null)
             {
                 this.OnCheckOutChanged(this.Edit.IsCheckedOut);
             }
             break;
     }
     SetActionCommandsAsync();
     this.OnStepChanged(_currentEnumStep.ToString());
 }
        public override async Task OnStepAsync(object stepName)
        {
            bool canProcess = true;
            EnumSteps step = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());
            switch (step)
            {
                case EnumSteps.Start:                    
                    this._CurrentEnumStep = EnumSteps.Start;
                    this.SystemSettings = await SystemSettingsFunctions.ReadSystemSettingsAsync();
                    if (this.SystemSettings == null)
                    {
                        this.SystemSettings = new LXMUserSystemSetting();
                    }
                    this.SetActionCommandsAsync();
                    break;
                case EnumSteps.Edit:
                    this.GridStyle = (Brush)Application.Current.FindResource("GridStyleEdit");
                    this.RaiseActionsWhenChangeStep(EnumScreen.SecuritySetting, EnumSteps.Edit);
                    this._CurrentEnumStep = EnumSteps.Edit;
                    this.IsCheckedOut = true;
                    this.SetActionCommandsAsync();
                    break;
                case EnumSteps.Save:
                    this.Validate();

                    if (this.HasErrors == false)
                    {
                        this.ValidateNotError();
                        this.GridStyle = (Brush)Application.Current.FindResource("GridStyleNotEdit");
                        this._CurrentEnumStep = EnumSteps.Save;
                        SystemSettingsFunctions.UpdateSystemSettings(this.SystemSettings);
                        this.RaiseActionsWhenChangeStep(EnumScreen.SecuritySetting, EnumSteps.Save);
                        this.IsCheckedOut = false;
                        this.IsChanged = false;
                        this.SetActionCommandsAsync();
                    }
                    else
                    {
                        this._CurrentEnumStep = EnumSteps.Error;
                        this.SetActionCommandsAsync();
                        this.OnErrorHyperlinkSelected();
                    }
                    break;
                case EnumSteps.Cancel:
                    canProcess = await this.CheckIfUnSavedChanges();
                    if (canProcess)
                    {
                        this.GridStyle = (Brush)Application.Current.FindResource("GridStyleNotEdit");
                        this._CurrentEnumStep = EnumSteps.Cancel;
                        this.SystemSettings = await SystemSettingsFunctions.ReadSystemSettingsAsync();
                        this.RaiseActionsWhenChangeStep(EnumScreen.SecuritySetting, EnumSteps.Cancel);
                        this.IsCheckedOut = false;
                        this.IsChanged = false;
                        this.SetActionCommandsAsync();
                    }
                    break;
                case EnumSteps.Error:
                    NotificationErrorView errorPopup = new NotificationErrorView();
                    NotificationErrorViewModel errorPopupViewModel = new NotificationErrorViewModel();
                    errorPopupViewModel.listCustomHyperlink = this.ListErrorHyperlink;
                    errorPopup.DataContext = errorPopupViewModel;

                    errorPopup.Style = (Style)Application.Current.FindResource("RadWindowStyleNew");

                    errorPopup.ShowDialog();
                    break;
            }
        }
        public override async Task OnStepAsync(object stepName)
        {
            GroupDetails group;
            this._CurrentEnumStep = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());
            switch (this._CurrentEnumStep)
            {
                case EnumSteps.Start:
                    await Task.WhenAll(this.PopulateAllUsersAsync(), this.PopulateAllGroupsAsync());
                    this.Managers = null;
                    break;
                case EnumSteps.SelectGroup:
                    if (this.SelectedGroup.IsNewGroup == false)
                    {
                        this.SelectedGroup.LXMGroup = await GroupFunctions.GetGroupAsync(this.SelectedGroup.UserEntityId);
                    }

                    if (this.AllUsers != null && this.Managers == null)
                    {
                        this.Managers = this.AllUsers.Select(user => new DropdownList { Description = string.Format("{0}{1}{2}", user.Lastname, string.IsNullOrEmpty(user.Lastname) == false ? ", " : "", user.Firstname), ID = user.UserEntityId }).ToList();
                    }

                    if (this.isCopy == false)
                    {
                        await this.PopulateUsersAndPermissionsForGroupAsync();
                    }
                    this.ActiveViewModel = this;
                    this.SetActionCommandsAsync();

                    if (this.IsCheckedOut)
                    {
                        await this.OnStepAsync(EnumSteps.Edit.ToString());
                    }
                    this.SelectedGroup.SystemOptionPermissionChanged -= SelectedGroup_SystemOptionPermissionChanged;
                    this.SelectedGroup.SystemOptionPermissionChanged += SelectedGroup_SystemOptionPermissionChanged;
                    break;
                case EnumSteps.CurrentGroup:
                    this.ActiveViewModel = this;
                    this.SetActionCommandsAsync();
                    break;
                case EnumSteps.DetailsState:
                case EnumSteps.UsersState:
                case EnumSteps.PermissionsState:
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(this._CurrentEnumStep.ToString());
                    }
                    break;
                case EnumSteps.Edit:
                    this.Edit.SelectedGroup = this.SelectedGroup;
                    this.Edit.NotMembers = new ObservableCollection<LXMUserDetail>(this.AllUsers.Except(this.SelectedGroup.Users));
                    await this.Edit.OnStepAsync(EditUserViewModel.EnumSteps.Start);
                    break;
                case EnumSteps.Add:
                    GroupDetails newGroup = await GroupFunctions.AddNewGroupAsync();
                    await SetSelectedGroupAsync(newGroup);                    
                    
                    await this.OnStepAsync(EnumSteps.Edit);
                    this.OnStoryBoardChanged(EnumSteps.DetailsState.ToString());
                    break;
                case EnumSteps.Copy:
                    this.isCopy = true;
                    GroupDetails copyGroup = await GroupFunctions.CopyGroupAsync(this.SelectedGroup);
                    copyGroup.IsNewGroup = true;
                    await SetSelectedGroupAsync(copyGroup);                   
                    await this.OnStepAsync(EnumSteps.Edit);
                    this.OnStoryBoardChanged(EnumSteps.DetailsState.ToString());
                    break;
                case EnumSteps.RefreshGroup:
                    group = this.Groups.Where(item => item.UserEntityId == this.SelectedGroup.UserEntityId).FirstOrDefault();

                    if (group == null)
                    {
                        group = this.SelectedGroup;
                        this.Groups.Add(group);
                    }

                    group.ManagerName = this.Managers.Where(manager => manager.ID == this.SelectedGroup.LXMGroup.ManagerUserEntityId).FirstOrDefault().Description;
                    break;
            }
            this.SetActionCommandsAsync();
            this.OnStepChanged(_CurrentEnumStep.ToString());
        }
        public override async Task OnStepAsync(object stepName)
        {
            UserDetails user;

            EnumSteps previousStep = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());

            this._CurrentEnumStep = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());
            switch (this._CurrentEnumStep)
            {
                case EnumSteps.Start:
                    await Task.WhenAll(this.PopulateStatesAsync(), this.PopulateAllGroupsAsync());
                    await this.PopulateAllUsersForViewAsync();
                    //this._OnLoadUserContent();
                    break;
                case EnumSteps.SelectUser:
                    GetSelectUser(EnumSteps.SelectUser);
                    if (this.SelectedUser.IsNewUser == false)
                    {
                        this.SelectedUser.LXMUserDetails = await UserFunctions.GetUserDetailsAsync(this.SelectedUser.UserEntityId);
                        await this.PopulateGroupsForUserAsync();
                    }

                    await this.PopulateCredentialsForUserAsync();

                    if (this.isCopy == false)
                    {
                        await this.PopulatePermissionsForUserAsync();
                    }

                    this.ActiveViewModel = this;
                    this.SetActionCommandsAsync();
                    if (this.IsCheckedOut)
                    {
                        await this.OnStepAsync(EnumSteps.Edit.ToString());
                    }
                    this.SelectedUser.SystemOptionPermissionChanged -= SelectedUser_SystemOptionPermissionChanged;
                    this.SelectedUser.SystemOptionPermissionChanged += SelectedUser_SystemOptionPermissionChanged;
                    break;
                case EnumSteps.PersonalDetailsState:
                case EnumSteps.CredentialsState:
                case EnumSteps.GroupsState:
                case EnumSteps.PermissionsState:
                case EnumSteps.SummaryState:
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(this._CurrentEnumStep.ToString());
                    }
                    break;
                case EnumSteps.Edit:
                    this.Edit.SelectedUser = this.SelectedUser;
                    this.Edit.NotAMemberOfGroups = new ObservableCollection<LXMGroup>(this.AllGroups.Except(this.SelectedUser.LXMUserGroups));
                    await this.Edit.OnStepAsync(EditUserViewModel.EnumSteps.Start);
                    break;
                case EnumSteps.Add:
                    UserDetails newUser = await UserFunctions.AddNewUserAsync();
                    await SetSelectedUserAsync(newUser);
                    await this.OnStepAsync(EnumSteps.Edit);
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(EnumSteps.PersonalDetailsState.ToString());
                    }
                    break;
                case EnumSteps.Copy:
                    this.isCopy = true;
                    UserDetails copyUser = await UserFunctions.CopyUserAsync(this.SelectedUser);
                    copyUser.IsNewUser = true;
                    await SetSelectedUserAsync(copyUser);
                    await this.OnStepAsync(EnumSteps.Edit);
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(EnumSteps.PersonalDetailsState.ToString());
                    }
                    break;
                case EnumSteps.RefreshUser:
                    user = this.AllUsers.Where(item => item.UserEntityId == this.SelectedUser.UserEntityId).FirstOrDefault();

                    if (user == null)
                    {
                        user = this.SelectedUser;
                        this.AllUsers.Add(user);
                    }
                    break;
            }
            this.SetActionCommandsAsync();
            this.OnStepChanged(_CurrentEnumStep.ToString());
        }
        /// <summary>
        /// update right hand grid when add or edit a record.
        /// </summary>
        /// <param name="currentStep">
        /// The current Step.
        /// </param>
        /// <param name="item">
        /// The item.
        /// </param>
        private void ContentViewModel_OnPropertyChanged(EnumSteps currentStep, object item)
        {
            switch (Screen)
            {
                #region User
                case EnumScreen.Users:
                    var mainWindowDetailsTabControlViewModelUsers =
                        this.ScreenDetailViewModel as MainWindowDetailsTabControlViewModel;
                    if (mainWindowDetailsTabControlViewModelUsers != null)
                    {
                        var usersViewModel =
                            mainWindowDetailsTabControlViewModelUsers.UsersMainWindowDetailsVm.ScreenDetailViewModel as
                            UsersViewModel;

                        if (usersViewModel != null && usersViewModel.AllUsers != null)
                        {
                            UserMapping userMapping = new UserMapping();

                            var user = usersViewModel.AllUsers.FirstOrDefault(x => x == item as UserDetails);
                                
                            if (user != null)
                            {
                                userMapping.UserEntityId = user.UserEntityId;
                                userMapping.LoginName = user.UserCredentials.LoginName;
                                userMapping.IsEnabled = user.UserCredentials.IsEnabled;
                                DataRow editItem = null;
                                foreach (var row in ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    var userDetails = item as UserDetails;
                                    if (userDetails != null && row["UserEntityId"].ToString() == userDetails.UserEntityId.ToString(CultureInfo.InvariantCulture))
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    ToggleViewModel.GridDynamicViewModel.InsertRow(index, userMapping);
                                }
                                else
                                {
                                    ToggleViewModel.GridDynamicViewModel.AddRow(userMapping);
                                }
                                ToggleViewModel.SetSelectedItem(user);
                            }
                        }
                    }
                    break;
                #endregion

                #region Group
                case EnumScreen.Groups:
                    var mainWindowDetailsTabControlViewModelGroups =
                        this.ScreenDetailViewModel as MainWindowDetailsTabControlViewModel;
                    if (mainWindowDetailsTabControlViewModelGroups != null)
                    {
                        var groupsViewModel =
                            mainWindowDetailsTabControlViewModelGroups.GroupsMainWindowDetailsVm.ScreenDetailViewModel
                            as GroupsViewModel;

                        if (groupsViewModel != null && groupsViewModel.Groups != null)
                        {
                            GroupMapping groupMapping = new GroupMapping();

                            var group = groupsViewModel.Groups.FirstOrDefault(x => x == item as GroupDetails);
                            if (group != null)
                            {
                                groupMapping.UserEntityId = group.UserEntityId;
                                groupMapping.GroupName = group.LXMGroup.GroupName;
                                DataRow editItem = null;
                                foreach (var row in ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    var groupDetails = item as GroupDetails;
                                    if (groupDetails != null && row["UserEntityId"].ToString() == groupDetails.UserEntityId.ToString(CultureInfo.InvariantCulture))
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    ToggleViewModel.GridDynamicViewModel.InsertRow(index, groupMapping);
                                }
                                else
                                {
                                    ToggleViewModel.GridDynamicViewModel.AddRow(groupMapping);
                                }
                                ToggleViewModel.SetSelectedItem(group);
                            }
                        }
                    }
                    break;
                #endregion

                #region ColletionQueues
                case EnumScreen.ColletionQueues:
                    var collectionQueueViewModel = this.ScreenDetailViewModel as MainWindowDetailsTabControlCollectionQueueViewModel;
                    QueueDetailsModel queueSource = item as QueueDetailsModel;
                    if (collectionQueueViewModel != null)
                    {
                        var collectionManagementViewModel =
                            collectionQueueViewModel.ListMainWindowDetailsVm.ScreenDetailViewModel as
                            CollectionsManagementViewModel;

                        if (collectionManagementViewModel != null
                            && collectionManagementViewModel.AllQueueManagementDetails != null)
                        {
                            CollectionsManagementMapping collectionsManagementMapping =
                                new CollectionsManagementMapping();
                            
                            var queue =
                                collectionManagementViewModel.AllQueueManagementDetails.FirstOrDefault(d => queueSource != null && d.QueueDetailId == queueSource.QueueDetailId);
                            if (queue != null)
                            {
                                collectionsManagementMapping.Enabled = queue.CollectionQueue.Enabled;
                                collectionsManagementMapping.ID = queue.CollectionQueue.ID;
                                collectionsManagementMapping.QueueName = queue.CollectionQueue.QueueName;
                                collectionsManagementMapping.AssignmentOrder = queue.CollectionQueue.AssignmentOrder;
                                DataRow editItem = null;
                                foreach (var row in ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    var queueDetailsModel = item as QueueDetailsModel;
                                    if (queueDetailsModel != null && row["ID"].ToString() == queueDetailsModel.QueueDetailId.ToString(CultureInfo.InvariantCulture))
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    ToggleViewModel.GridDynamicViewModel.InsertRow(index, collectionsManagementMapping);
                                }
                                else
                                {
                                    ToggleViewModel.GridDynamicViewModel.AddRow(collectionsManagementMapping);
                                }
                                ToggleViewModel.SetSelectedItem(queue);
                            }
                        }
                    }
                    break;
                #endregion

                #region CollectionAssignment
                case EnumScreen.CollectionAssignment:
                    var collectionAssignmentViewModel =
                        this.ScreenDetailViewModel as MainWindowDetailsViewModel;
                    if (collectionAssignmentViewModel != null)
                    {
                        var viewModel = collectionAssignmentViewModel.ScreenDetailViewModel as CollectionsAssignmentViewModel;
                        CollectionAssignmentModel itemSource = item as CollectionAssignmentModel;
                        if (viewModel != null && itemSource != null)
                        {
                            CollectionAssignmentMapping collectionAssignmentMapping =
                                new CollectionAssignmentMapping();
                            
                            var collectionAssignment =
                                viewModel.FilteredItems.FirstOrDefault(d => d.QueueID == itemSource.QueueID && d.ContractId == itemSource.ContractId);

                            if (collectionAssignment != null)
                            {
                                collectionAssignmentMapping.QueueID = collectionAssignment.QueueID;
                                collectionAssignmentMapping.FollowUpDate = collectionAssignment.FollowUpDate;
                                collectionAssignmentMapping.ContractId = collectionAssignment.ContractId;
                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    var collectionAssignmentModel = item as CollectionAssignmentModel;
                                    if (row["QueueID"].ToString() == collectionAssignmentModel.QueueID.ToString(CultureInfo.InvariantCulture) && row["ContractId"].ToString() == collectionAssignmentModel.ContractId.ToString(CultureInfo.InvariantCulture))
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    this.ToggleViewModel.GridDynamicViewModel.InsertRow(index, collectionAssignmentMapping);
                                }
                                else
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.AddRow(collectionAssignmentMapping);
                                }
                                this.ToggleViewModel.SetSelectedItem(collectionAssignment);
                            }
                            
                        }
                    }
                    break;
                #endregion

                #region FundingSummary
                case EnumScreen.FundingSummary:
                    var fundingViewModel =
                        this.ScreenDetailViewModel as MainWindowDetailsViewModel;
                    if (fundingViewModel != null)
                    {
                        var fundingSummaryViewModel =
                            fundingViewModel.ScreenDetailViewModel as
                            FundingSummaryViewModel;
                        
                        FundingSummaryMaping fundingSummaryMapping =
                                new FundingSummaryMaping();
                        if (fundingSummaryViewModel != null)
                        {
                            var fundingSummary =
                                fundingSummaryViewModel.TrancheSummary.FirstOrDefault(x => x.TrancheId == (int)item);
                            
                            if (fundingSummary != null)
                            {
                                fundingSummaryMapping.TrancheId = fundingSummary.TrancheId;
                                fundingSummaryMapping.FunderName = fundingSummary.FunderName;
                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["TrancheId"].ToString() == item.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);                                    
                                    this.ToggleViewModel.GridDynamicViewModel.InsertRow(
                                            index,
                                            fundingSummaryMapping);
                                }
                                else
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.AddRow(fundingSummaryMapping);
                                }
                                this.ToggleViewModel.SetSelectedItem(fundingSummary);
                            }
                            else
                            {
                                if (currentStep == EnumSteps.Delete)
                                {
                                    DataRow editItem = null;
                                    foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                    {
                                        if (row["TrancheId"].ToString() == item.ToString())
                                        {
                                            editItem = row;
                                            break;
                                        }
                                    }
                                    if (editItem != null)
                                    {
                                        this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = false;
                                        int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                        this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    }
                                    this.ToggleViewModel.SetSelectedItem(null);
                                }
                            }
                        }
                    }
                    break;
                #endregion

                #region Asset Class Category
                case EnumScreen.AssetClassesCategory:
                    var mainWindowDetailsTabControlViewModelCategory =
                        this.ScreenDetailViewModel as MainAssetClassesViewModel;
                    if (mainWindowDetailsTabControlViewModelCategory != null)
                    {
                        var categoryViewModel =
                            mainWindowDetailsTabControlViewModelCategory.AssetCategoryViewModel.ScreenDetailViewModel as
                            AssetClassesCategoryViewModel;

                        if (categoryViewModel != null && categoryViewModel.ListDataGridItem != null)
                        {
                            AssetClassesCategoryRowItem categoryMapping = new AssetClassesCategoryRowItem();

                            var category = categoryViewModel.ListDataGridItem.FirstOrDefault(x => x.EquipCategoryId == (item as EquipCategory).EquipCatId);

                            if (category != null)
                            {
                                categoryMapping.EquipCategoryId = (item as EquipCategory).EquipCatId;
                                categoryMapping.Category = (item as EquipCategory).Description;
                                categoryMapping.Enabled = (item as EquipCategory).Enabled;
                                DataRow editItem = null;
                                foreach (var row in ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["EquipCategoryId"].ToString() == (item as EquipCategory).EquipCatId.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    ToggleViewModel.GridDynamicViewModel.InsertRow(index, categoryMapping);
                                }
                                else
                                {
                                    ToggleViewModel.GridDynamicViewModel.AddRow(categoryMapping);
                                }
                                ToggleViewModel.SetSelectedItem(item);
                            }
                        }
                    }
                    break;
                #endregion

                #region Asset Class Type
                case EnumScreen.AssetClassesType:
                    var mainWindowDetailsTabControlViewModelType =
                        this.ScreenDetailViewModel as MainAssetClassesViewModel;
                    if (mainWindowDetailsTabControlViewModelType != null)
                    {
                        var typeViewModel =
                            mainWindowDetailsTabControlViewModelType.AssetClassesTypeViewModel.ScreenDetailViewModel as AssetClassesTypeViewModel;

                        if (typeViewModel != null && typeViewModel.ListDataGridItem != null)
                        {
                            AssetClassesTypeRowItem typeMapping = new AssetClassesTypeRowItem();

                            var type = typeViewModel.ListDataGridItem.FirstOrDefault(x => x.EquipTypeId == (item as EquipType).EquipTypeId);

                            if (type != null)
                            {
                                typeMapping.EquipTypeId = (item as EquipType).EquipTypeId;
                                typeMapping.TypeDescription = (item as EquipType).Description;
                                typeMapping.Enabled = (item as EquipType).Enabled;
                                DataRow editItem = null;
                                foreach (var row in ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["EquipTypeId"].ToString() == (item as EquipType).EquipTypeId.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    ToggleViewModel.GridDynamicViewModel.InsertRow(index, typeMapping);
                                }
                                else
                                {
                                    ToggleViewModel.GridDynamicViewModel.AddRow(typeMapping);
                                }
                                ToggleViewModel.SetSelectedItem(item);
                            }
                        }
                    }
                    break;
                #endregion

                #region AssetClassesModel
                case EnumScreen.AssetClassesModel:
                    var modelViewModel = this.ScreenDetailViewModel as MainAssetClassesViewModel;
                    if (modelViewModel != null)
                    {
                        var modelDetailViewModel = modelViewModel.AssetClassesModelViewModel.ScreenDetailViewModel
                            as AssetClassesModelViewModel;
                        AssetClassesModelRowItem assetModelMapping=new AssetClassesModelRowItem();
                        if (modelDetailViewModel != null)
                        {
                            var assetDetail =
                                modelDetailViewModel.AllAssetModel.FirstOrDefault(x=> x.EquipModelId == ((EquipModel)item).EquipModelId);

                            if (assetDetail != null)
                            {
                                assetModelMapping.EquipModelId = assetDetail.EquipModelId;
                                assetModelMapping.Description = assetDetail.Description;
                                assetModelMapping.Enabled = assetDetail.Enabled;
                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["EquipModelId"].ToString() == ((EquipModel)item).EquipModelId.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    this.ToggleViewModel.GridDynamicViewModel.InsertRow(
                                            index,
                                            assetModelMapping);
                                }
                                else
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.AddRow(assetModelMapping);
                                }
                                this.ToggleViewModel.SetSelectedItem(item);
                            }
                        }
                    }
                    break;
                #endregion

                #region AssetFeatures
                case EnumScreen.AssetFeatures:
                    var featureViewModel =
                        this.ScreenDetailViewModel as MainWindowDetailsViewModel;
                    if (featureViewModel != null)
                    {
                        var assetFeatureViewModel =
                            featureViewModel.ScreenDetailViewModel as
                            AssetFeaturesViewModel;

                        AssetFeatureTypeRowItem featureTypeMapping =
                                new AssetFeatureTypeRowItem();
                        if (assetFeatureViewModel != null)
                        {
                            var feature =
                                assetFeatureViewModel.AllFeatureTypes.FirstOrDefault(x => x.FeatureTypeId == (int)item);

                            if (feature != null)
                            {
                                featureTypeMapping.FeatureTypeId = feature.FeatureTypeId;
                                featureTypeMapping.FeatureName = feature.FeatureName;
                                featureTypeMapping.Enabled = feature.Enabled;
                                featureTypeMapping.RequiredLength = feature.RequiredLength == -1 ? "N/A" : feature.RequiredLength.ToString();
                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["FeatureTypeId"].ToString() == item.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    this.ToggleViewModel.GridDynamicViewModel.InsertRow(
                                            index,
                                            featureTypeMapping);
                                }
                                else
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.AddRow(featureTypeMapping);
                                }
                                this.ToggleViewModel.SetSelectedItem(feature);
                            }
                            else
                            {
                                if (currentStep == EnumSteps.Delete)
                                {
                                    DataRow editItem = null;
                                    foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                    {
                                        if (row["FeatureTypeId"].ToString() == item.ToString())
                                        {
                                            editItem = row;
                                            break;
                                        }
                                    }
                                    if (editItem != null)
                                    {
                                        this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = false;
                                        int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                        this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    }
                                    this.ToggleViewModel.SetSelectedItem(null);
                                }
                            }
                        }
                    }
                    break;
                #endregion

                #region AssetClassesMake
                case EnumScreen.AssetClassesMake:
                    var makeViewModel =
                        this.ScreenDetailViewModel as MainAssetClassesViewModel;
                    if (makeViewModel != null)
                    {
                        var assetClassesMakeViewModel = makeViewModel.AssetClassesMakeViewModel.ScreenDetailViewModel as AssetClassesMakeViewModel;

                        AssetClassesMakeRowItem makeTypeMapping = new AssetClassesMakeRowItem();
                        if (assetClassesMakeViewModel != null)
                        {
                            var make =
                                assetClassesMakeViewModel.AllAssetMake.FirstOrDefault(x => x.EquipMakeId == (int)item);

                            if (make != null)
                            {
                                makeTypeMapping.EquipMakeId = make.EquipMakeId;
                                makeTypeMapping.Description = make.Description;
                                makeTypeMapping.Enabled = make.Enabled;
                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["EquipMakeId"].ToString() == item.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index =
                                        this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    this.ToggleViewModel.GridDynamicViewModel.InsertRow(index, makeTypeMapping);
                                }
                                else
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.AddRow(makeTypeMapping);
                                }
                                this.ToggleViewModel.SetSelectedItem(make);
                            }
                        }
                    }
                    break;
                #endregion

                #region Asset Collateral Classes
                case EnumScreen.AssetCollateralClasses:
                    var collateralViewModel =
                        this.ScreenDetailViewModel as MainWindowDetailsViewModel;
                    if (collateralViewModel != null)
                    {
                        var assetCollateralViewModel =
                            collateralViewModel.ScreenDetailViewModel as
                            AssetCollateralClassesViewModel;

                        AssetCollateralRowItem collateralMapping =
                                new AssetCollateralRowItem();
                        if (assetCollateralViewModel != null)
                        {
                            var collateral =
                                assetCollateralViewModel.AllCollateralClasses.FirstOrDefault(x => x.CollateralClassID == (int)item);

                            if (collateral != null)
                            {
                                collateralMapping.Description = collateral.Description;
                                collateralMapping.CollateralClassID = collateral.CollateralClassID;
                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["CollateralClassID"].ToString() == item.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    this.ToggleViewModel.GridDynamicViewModel.InsertRow(
                                            index,
                                            collateralMapping);
                                }
                                else
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.AddRow(collateralMapping);
                                }
                                this.ToggleViewModel.SetSelectedItem(collateral);
                            }
                        }
                    }
                    break;
                #endregion

                #region AssetRegister
                case EnumScreen.AssetRegisters:
                    var registerViewModel =
                        this.ScreenDetailViewModel as MainWindowDetailsViewModel;
                    if (registerViewModel != null)
                    {
                        var assetRegisterViewModel =
                            registerViewModel.ScreenDetailViewModel as AssetRegistersViewModel;

                        AssetRegisterRowItem registerMapping = new AssetRegisterRowItem();
                        if (assetRegisterViewModel != null)
                        {
                            var register = assetRegisterViewModel.AllAssetRegister.FirstOrDefault(x => x.ID == (int)item);

                            if (register != null)
                            {
                                registerMapping.ID = register.ID;
                                registerMapping.RegisterName = register.RegisterName;
                                registerMapping.InternalOnly = register.InternalOnly;

                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["ID"].ToString() == item.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    this.ToggleViewModel.GridDynamicViewModel.InsertRow(index, registerMapping);
                                }
                                else
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.AddRow(registerMapping);
                                }
                                this.ToggleViewModel.SetSelectedItem(register);
                            }
                            else
                            {
                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["ID"].ToString() == item.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }
                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = false;
                                    int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                }
                                this.ToggleViewModel.SetSelectedItem(null);
                            }
                        }
                    }
                    break;
                #endregion

                #region RegisteredAsset
                case EnumScreen.RegisteredAsset:
                    var registeredAssetViewModel =
                        this.ScreenDetailViewModel as MainWindowDetailsViewModel;
                    if (registeredAssetViewModel != null)
                    {
                        var assetRegisterViewModel =
                            registeredAssetViewModel.ScreenDetailViewModel as RegisteredAssetViewModel;

                        RegisteredAssetRowItem registerMapping = new RegisteredAssetRowItem();
                        if (assetRegisterViewModel != null)
                        {
                            var register = assetRegisterViewModel.AllRegisteredAsset.FirstOrDefault(x => x.Id == (int)item);

                            if (register != null)
                            {
                                registerMapping.Id = register.Id;
                                registerMapping.AssetRegisterId = register.AssetRegisterId;
                                registerMapping.AssetState = register.AssetState;

                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["Id"].ToString() == item.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }

                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = true;
                                    int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                    this.ToggleViewModel.GridDynamicViewModel.InsertRow(index, registerMapping);
                                }
                                else
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.AddRow(registerMapping);
                                }
                                this.ToggleViewModel.SetSelectedItem(register);
                            }
                            else
                            {
                                DataRow editItem = null;
                                foreach (var row in this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows)
                                {
                                    if (row["Id"].ToString() == item.ToString())
                                    {
                                        editItem = row;
                                        break;
                                    }
                                }
                                if (editItem != null)
                                {
                                    this.ToggleViewModel.GridDynamicViewModel.IsSetSelectedItem = false;
                                    int index = this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.IndexOf(editItem);
                                    this.ToggleViewModel.GridDynamicViewModel.MembersTable.Rows.RemoveAt(index);
                                }
                                this.ToggleViewModel.SetSelectedItem(null);
                            }
                        }
                    }
                    break;
                #endregion
            }
        }
        /// <summary>
        /// The on step async.
        /// </summary>
        /// <param name="stepName">
        /// The step name.
        /// </param>
        /// <returns>
        /// The <see cref="Task"/>.
        /// </returns>
        public override async Task OnStepAsync(object stepName)
        {
            bool canProcess;
            var step = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());
            switch (step)
            {
                case EnumSteps.Start:
                    this._CurrentEnumStep = EnumSteps.Start;
                    this.AssetSettings = await AssetSettingsFunctions.ReadAssetClassSettings();
                    var allCategoryDefault = new ObservableCollection<EquipCategory>(await AssetSettingsFunctions.ReadAllCategoryDefaultAssetSystemSettingsAsync());
                    allCategoryDefault.Add(new EquipCategory
                    {
                        EquipCatId = -1,
                        Description = "<None>",
                    });
                    this.Category =
                    allCategoryDefault.Select(
                    cate => new DropdownList { Description = cate.Description, ID = cate.EquipCatId })
                    .OrderBy(item => item.Description)
                    .ToList();
                    if (this.AssetSettings != null)
                    {
                        this.SelectedCategory = this.Category.FirstOrDefault(x => x.ID == this.AssetSettings.DefaultCategoryID);
                    }

                    this.SetBackgroundToNotEdit();
                    this.SetActionCommandsAsync();
                    break;
                case EnumSteps.Edit:
                    if (await this.LockAsync())
                    {
                        this.SetBackgroundToEdit();
                        this.RaiseActionsWhenChangeStep(EnumScreen.AssetSettings, EnumSteps.Edit);
                        this._CurrentEnumStep = EnumSteps.Edit;
                        this.SetActionCommandsAsync();
                    }

                    break;
                case EnumSteps.Save:
                    this.Validate();
                    if (this.HasErrors == false)
                    {
                        this.ValidateNotError();
                        this.ClearNotifyErrors();
                        await this.UnLockAsync();
                        this.SetBackgroundToNotEdit();
                        if (this.SelectedCategory != null)
                        {
                            this.AssetSettings.DefaultCategoryID = this.SelectedCategory.ID;
                        }
                        else
                        {
                            await this.CheckCategoryIsEnalbe(this.CurrentCategory);
                            this.AssetSettings.DefaultCategoryID = this.SelectedCategory.ID;
                        }

                        if (!this.AssetSettings.IncludeMake)
                        {
                            this.AssetSettings.IncludeModel = false;
                        }

                        await AssetSettingsFunctions.UpdateAssetClassSettings(this.AssetSettings);
                        this.RaiseActionsWhenChangeStep(EnumScreen.AssetSettings, EnumSteps.Save);
                        this._CurrentEnumStep = EnumSteps.Save;
                        await this.OnStepAsync(EnumSteps.Start);
                        this.SetActionCommandsAsync();
                    }
                    else
                    {
                        this._CurrentEnumStep = EnumSteps.Error;
                        this.SetActionCommandsAsync();
                        this.OnErrorHyperlinkSelected();
                    }

                    break;
                case EnumSteps.Cancel:
                    canProcess = await this.CheckIfUnSavedChanges();
                    if (canProcess)
                    {
                        this.ValidateNotError();
                        this.ClearNotifyErrors();
                        await this.UnLockAsync();
                        this.SetBackgroundToNotEdit();
                        this._CurrentEnumStep = EnumSteps.Cancel;
                        await this.OnStepAsync(EnumSteps.Start);
                        this.RaiseActionsWhenChangeStep(EnumScreen.AssetSettings, EnumSteps.Cancel);
                        this.SetActionCommandsAsync();
                    }

                    break;
                case EnumSteps.Error:
                    NotificationErrorView errorPopup = new NotificationErrorView();
                    NotificationErrorViewModel errorPopupViewModel = new NotificationErrorViewModel();
                    errorPopupViewModel.listCustomHyperlink = this.ListErrorHyperlink;
                    errorPopup.DataContext = errorPopupViewModel;
                    errorPopup.Style = (Style)Application.Current.FindResource("RadWindowStyleNew");
                    errorPopup.ShowDialog();
                    break;
            }
        }
        public override async Task OnStepAsync(object stepName)
        {
            bool canProcess = true;
            var step = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());
            switch (step)
            {
                case EnumSteps.Start:
                    _CurrentEnumStep = EnumSteps.Start;
                    CollectionQueueSetting = await CollectionsQueueSettingsFunctions.ReadCollectionsSystemSettingsAsync() ??
                                             new CollectionSetting();

                    CollectionSystemDefault = await CollectionsQueueSettingsFunctions.ReadCollectionSystemDefaultAsync() ??
                                              new CollectionSystemDefault();

                    var allSystemParam = new ObservableCollection<SystemParam>(await CollectionsQueueSettingsFunctions.ReadAllSystemParamAsync());
                    Category = allSystemParam
                        .Select(cate => new DropdownList { Description = cate.ParamDesc, ID = cate.ParamId })
                        .OrderBy(item => item.Description)
                        .ToList();

                    SetActionCommandsAsync();
                    break;

                case EnumSteps.Edit:
                    this.GridStyle = (Brush)Application.Current.FindResource("GridStyleEdit");
                    this.RaiseActionsWhenChangeStep(EnumScreen.CollectionSettings, EnumSteps.Edit);
                    _CurrentEnumStep = EnumSteps.Edit;
                    IsCheckedOut = true;
                    SetActionCommandsAsync();
                    break;

                case EnumSteps.Save:
                    if (IsPercentaged)
                    {
                        CollectionQueueSetting.MinimumArrearsAmount = 0;
                    }
                    else
                    {
                        CollectionQueueSetting.MinimumArrearsPercent = 0;
                    }
                    Validate();

                    if (HasErrors == false)
                    {
                        this.ValidateNotError();
                        this.GridStyle = (Brush)Application.Current.FindResource("GridStyleNotEdit");
                        _CurrentEnumStep = EnumSteps.Save;
                        await CollectionsQueueSettingsFunctions.UpdateCollectionsSystemSettings(CollectionQueueSetting, CollectionSystemDefault);
                        this.RaiseActionsWhenChangeStep(EnumScreen.CollectionSettings, EnumSteps.Save);
                        IsCheckedOut = false;
                        this.IsChanged = false;
                        SetActionCommandsAsync();
                    }
                    else
                    {
                        _CurrentEnumStep = EnumSteps.Error;
                        this.SetActionCommandsAsync();
                        this.ListErrorHyperlink = this.ListErrorHyperlink;
                        this.OnErrorHyperlinkSelected();
                    }
                    break;

                case EnumSteps.Cancel:
                    canProcess = await this.CheckIfUnSavedChanges();
                    if (canProcess)
                    {
                        this.ValidateNotError();
                        this.GridStyle = (Brush)Application.Current.FindResource("GridStyleNotEdit");
                        _CurrentEnumStep = EnumSteps.Cancel;
                        CollectionQueueSetting =
                            await CollectionsQueueSettingsFunctions.ReadCollectionsSystemSettingsAsync();
                        CollectionQueueSetting.tempMinimumArrearsPercent =
                            CollectionQueueSetting.MinimumArrearsPercent.HasValue
                                ? CollectionQueueSetting.MinimumArrearsPercent.Value.ToString(
                                    CultureInfo.InvariantCulture)
                                : "0";
                        CollectionQueueSetting.tempMinimumArrearsAmount =
                            CollectionQueueSetting.MinimumArrearsAmount.HasValue
                                ? CollectionQueueSetting.MinimumArrearsAmount.Value.ToString(
                                    CultureInfo.InvariantCulture)
                                : "0";
                        CollectionQueueSetting.tempMinimumArrearsDays =
                            CollectionQueueSetting.MinimumArrearsDays.HasValue
                                ? CollectionQueueSetting.MinimumArrearsDays.Value.ToString(CultureInfo.InvariantCulture)
                                : "0";
                        CollectionSystemDefault =
                            await CollectionsQueueSettingsFunctions.ReadCollectionSystemDefaultAsync();
                        this.RaiseActionsWhenChangeStep(EnumScreen.CollectionSettings, EnumSteps.Cancel);
                        IsCheckedOut = false;
                        this.IsChanged = false;
                        SetActionCommandsAsync();
                    }
                    break;
                case EnumSteps.Error:
                    NotificationErrorView errorPopup = new NotificationErrorView();
                    NotificationErrorViewModel errorPopupViewModel = new NotificationErrorViewModel();
                    errorPopupViewModel.listCustomHyperlink = this.ListErrorHyperlink;
                    errorPopup.DataContext = errorPopupViewModel;

                    errorPopup.Style = (Style)Application.Current.FindResource("RadWindowStyleNew");

                    errorPopup.ShowDialog();
                    break;
            }
        }
        public override async Task OnStepAsync(object stepName)
        {
            this._CurrentEnumStep = (EnumSteps)Enum.Parse(typeof(EnumSteps), stepName.ToString());
            switch (this._CurrentEnumStep)
            {
                case EnumSteps.Start:
                    await this.OnStart();
                    break;

                case EnumSteps.SelectQueue:
                    this.GridStyle = (Brush)Application.Current.FindResource("GridStyleNotEdit");
                    this.SetBusyAction(LoadingText);
                    this.Edit.SetBusyAction(LoadingText);
                    await this.OnSelectQueue();
                    this.SetActionCommandsAsync();
                    this.ResetBusyAction();
                    this.Edit.ResetBusyAction();
                    if (IsChangeContent)
                    {
                        this.RaiseActionsWhenChangeStep(EnumScreen.CollectionAssignment, EnumSteps.SelectQueue, this.SelectedQueue);
                    }
                    break;

                case EnumSteps.Details:
                    this.CurrentStep = EnumSteps.Details;
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(this._CurrentEnumStep.ToString());
                    }

                    this.SetActionCommandsAsync();
                    break;
                case EnumSteps.Activity:
                    this.CurrentStep = EnumSteps.Activity;
                    if (this.OnStoryBoardChanged != null)
                    {
                        this.OnStoryBoardChanged(this._CurrentEnumStep.ToString());
                    }

                    this.SetActionCommandsAsync();
                    break;

                case EnumSteps.CurrentQueue:
                    this.GridStyle = (Brush)Application.Current.FindResource("GridStyleNotEdit");
                    this.ActiveViewModel = this;
                    this.Edit.IsCheckedOut = false;
                    this.OriginalSelectedAssignee = null;
                    // await Task.WhenAll(this.PopulateAllCollectionsQueuesAssignmentAsync());
                    CollectionAssignmentModel item = await RefreshSelectedItem();
                    RefreshGridData(item);
                    this.SetActionCommandsAsync();
                    break;

                case EnumSteps.Edit:
                    //if (await this.LockAsync() == false)
                    //{
                    //    return;
                    //}
                    this.RaiseActionsWhenChangeStep(EnumScreen.CollectionAssignment, EnumSteps.Edit);
                    this.GridStyle = (Brush)Application.Current.FindResource("GridStyleEdit");
                    this.Edit.SelectedQueue = this.SelectedQueue;
                    this.Edit.InstanceGUID = this.InstanceGUID;
                    this.OriginalSelectedAssignee = this.SelectedAssignee;
                    await this.Edit.OnStepAsync(QueueAssignmentDetailsViewModel.EnumSteps.Start);

                    // check if the cancellation has been requested for this action
                    if (CancellationToken.IsCancellationRequested)
                    {
                        return;
                    }

                    this.SetActionCommandsAsync();
                    break;

                case EnumSteps.Previous:
                    SetBusyAction(LoadingText);
                    await this.OnPrevious();
                    if (SelectedItemChanged != null)
                    {
                        SelectedItemChanged(this.SelectedQueue);
                    }
                    ResetBusyAction();
                    break;

                case EnumSteps.Next:
                    SetBusyAction(LoadingText);
                    await this.OnNext();
                    if (SelectedItemChanged != null)
                    {
                        SelectedItemChanged(this.SelectedQueue);
                    }
                    ResetBusyAction();
                    break;

                case EnumSteps.Refresh:
                    // this.OnRefresh();
                    SetBusyAction(LoadingText);
                    await this.RefreshDataOnFilter();

                    // check if the cancellation has been requested for this action
                    if (CancellationToken.IsCancellationRequested)
                    {
                        return;
                    }

                    // Indicate we are no longer Busy
                    ResetBusyAction();
                    break;
                case EnumSteps.AssignmentFilter:
                    SetBusyAction(LoadingText);
                    await this.RefreshDataOnFilter();
                    // check if the cancellation has been requested for this action
                    if (CancellationToken.IsCancellationRequested)
                    {
                        return;
                    }

                    // Indicate we are no longer Busy
                    ResetBusyAction();
                    break;
            }
        }