RiaTasks: Central Silverlight Business Rules Validation

using System;
using System.Linq;
using System.ComponentModel;
using RIATasks.wsRIATasks;
using System.Collections.ObjectModel;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows;
using System.Collections.Generic;

namespace RIATasks
{
    public class TabControlModel : INotifyPropertyChanged
    {
        public TabControlModel()
        {
            AddNewTaskCommand = new DelegateCommand(AddNewTask, CanAddNewTask);
            DeleteTaskCommand = new DelegateCommand(DeleteTask, CanDeleteTask);
            UpdateTaskCommand = new DelegateCommand(UpdateTask, CanUpdateTask);

            // The following line prevents Expression Blend
            // from showing an error when in design mode
            if (!DesignerProperties.IsInDesignTool)
            {
                // Get the Tasks for the current user
                GetTasks();
            }
        }

        #region AddNewTaskCommand
        public ICommand AddNewTaskCommand { get; set; }
        public void AddNewTask(object param)
        {
            SetToNewTask();
        }

        private bool CanAddNewTask(object param)
        {
            // Only allow a New Task to be created
            // If there are no other [New] Tasks

            var colNewTasks = from Tasks in colTabItems
                              where (Tasks.Header as string).Contains("[New]")
                              select Tasks;

            return (colNewTasks.Count() == 0);
        }
        #endregion

        #region DeleteTaskCommand
        public ICommand DeleteTaskCommand { get; set; }
        public void DeleteTask(object param)
        {
            // Get The Task
            Task objTask = GetTaskFromTaskDetails((param as TaskDetails));

            if (objTask.TaskID != -1)
            {
                // Delete Task
                DeleteTask(objTask);
            }
            else
            {
                RemoveTask(objTask.TaskID);
            }
        }

        private bool CanDeleteTask(object param)
        {
            // Only allow this ICommand to fire 
            // if a TaskDetails was passed as a parameter
            return ((param as TaskDetails) != null);
        }
        #endregion

        #region UpdateTaskCommand
        public ICommand UpdateTaskCommand { get; set; }
        public void UpdateTask(object param)
        {
            // Get The Task
            Task objTask = GetTaskFromTaskDetails((param as TaskDetails));

            if (objTask.TaskID == -1)
            {
                // This is a new Task
                InsertTask(objTask);
            }
            else
            {
                // This is an Update
                UpdateTask(objTask);
            }
        }

        private bool CanUpdateTask(object param)
        {
            // Only allow this ICommand to fire 
            // if a TaskDetails was passed as a parameter
            return ((param as TaskDetails) != null);
        }
        #endregion

        // Operations

        #region DeleteTask
        private void DeleteTask(Task objTask)
        {
            // Call the Model to delete the Task
            TasksModel.DeleteTask(objTask.TaskID, (Param, EventArgs) =>
            {
                if (EventArgs.Error == null)
                {
                    // Show any errors
                    Message = EventArgs.Result.Errors.ToList();
                    // Set the visibility of the Message ListBox
                    MessageVisibility = (Message.Count > 0) ? Visibility.Visible : Visibility.Collapsed;

                    RemoveTask(objTask.TaskID);
                }
            });
        }
        #endregion

        #region UpdateTask
        private void UpdateTask(Task objTask)
        {
            // Call the Model to UpdateTask the Task
            TasksModel.UpdateTask(objTask, (Param, EventArgs) =>
            {
                if (EventArgs.Error == null)
                {
                    // Show any errors
                    Task objResultTask = EventArgs.Result;

                    Message = objResultTask.Errors.ToList();
                    // Set the visibility of the Message ListBox
                    MessageVisibility = (Message.Count > 0) ? Visibility.Visible : Visibility.Collapsed;
                }
            });
        }
        #endregion

        #region InsertTask
        private void InsertTask(Task objTask)
        {
            // Call the Model to Insert the Task
            TasksModel.InsertTask(objTask, (Param, EventArgs) =>
            {
                if (EventArgs.Error == null)
                {
                    // Set the CurrentTaskID Property
                    // So it can be selected when Tasks re-load
                    CurrentTaskID = EventArgs.Result.TaskID;

                    // Show any errors
                    Message = EventArgs.Result.Errors.ToList();
                    // Set the visibility of the Message ListBox
                    MessageVisibility = (Message.Count > 0) ? Visibility.Visible : Visibility.Collapsed;

                    // If there are no errors - refresh Task List
                    if (Message.Count == 0)
                    {
                        GetTasks();
                    }
                }
            });
        }
        #endregion

        #region GetTasks
        private void GetTasks()
        {
            // Clear the current Tasks
            colTabItems.Clear();

            // Call the Model to get the collection of Tasks
            TasksModel.GetTasks((Param, EventArgs) =>
            {
                if (EventArgs.Error == null)
                {
                    // loop thru each item
                    foreach (var objTask in EventArgs.Result)
                    {
                        // Create a TaskItem from the Task
                        TabItem objTabItem = CreateTaskItem(objTask);

                        // Add it to the Collection of TabItems
                        colTabItems.Add(objTabItem);
                    }

                    // Count the records returned
                    if (colTabItems.Count == 0)
                    {
                        // If there are no records, indicate that
                        Message.Clear();
                        Message.Add("No Records Found");
                        MessageVisibility = Visibility.Visible;
                    }
                    else
                    {
                        Message.Clear();
                        MessageVisibility = Visibility.Collapsed;
                    }

                    // If there is a CurrentTaskID set that 
                    // as the Current task
                    if (CurrentTaskID != -1)
                    {
                        // Locate the Task
                        var objTabItem = (from TaskItem in colTabItems
                                          let VM = (TaskItem.Content as TaskDetails).DataContext
                                          where (VM as TaskDetailsModel).CurrentTask.TaskID == CurrentTaskID
                                          select TaskItem).FirstOrDefault();

                        if (objTabItem != null)
                        {
                            // Set the CurrentTask as selected
                            objTabItem.IsSelected = true;
                        }
                    }
                }
            });
        }
        #endregion

        #region SetToNewTask
        private void SetToNewTask()
        {
            // Unset selected for all Items
            foreach (var item in colTabItems)
            {
                item.IsSelected = false;
            }

            // Create a empty Task
            // so form will be blank
            Task objTask = new Task();

            // Set TaskID = -1 so we know it's a new Task
            objTask.TaskID = -1;

            // Create a TaskItem from the Task
            TabItem objNewTabItem = CreateTaskItem(objTask);

            // Set it as selected
            objNewTabItem.IsSelected = true;

            // Add it to the Collection of TabItems
            this.colTabItems.Add(objNewTabItem);
        }
        #endregion

        #region RemoveTask
        private void RemoveTask(int TaskID)
        {
            // Locate the Task
            var objTabItem = (from TaskItem in colTabItems
                              let VM = (TaskItem.Content as TaskDetails).DataContext
                              where (VM as TaskDetailsModel).CurrentTask.TaskID == TaskID
                              select TaskItem).FirstOrDefault();

            if (objTabItem != null)
            {
                // Remove the Task
                colTabItems.Remove(objTabItem);
            }
        }
        #endregion

        #region CreateTaskItem
        private TabItem CreateTaskItem(Task Task)
        {
            // Create a Tasks Details
            TaskDetails objTaskDetails = new TaskDetails();
            // Get it's DataContext
            TaskDetailsModel objTaskDetailsModel = (TaskDetailsModel)objTaskDetails.DataContext;
            // Call a method to set the Current Task at it's DataContext
            objTaskDetailsModel.SetCurrentTask(Task);

            // Create a TabItem 
            TabItem objTabItem = new TabItem();
            // Give it a name so it can be programatically manipulated
            objTabItem.Name = string.Format("DynamicTab_{0}", Task.TaskID.ToString());
            // Set the Style to point to a Resource that te Designer
            // can later change
            objTabItem.Style = (Style)App.Current.Resources["TabItemStyle1"];
            // Set it's Header
            string strTaskID = (Task.TaskID == -1) ? "[New]" : Task.TaskID.ToString();
            objTabItem.Header = String.Format("Task {0}", strTaskID);
            // Set it's Content to the Tasks Details control
            objTabItem.Content = objTaskDetails;
            return objTabItem;
        }
        #endregion

        #region GetTaskFromTaskDetails
        private Task GetTaskFromTaskDetails(TaskDetails objTaskDetails)
        {
            // Get TaskDetailsModel from 
            TaskDetailsModel objTaskDetailsModel = (TaskDetailsModel)objTaskDetails.DataContext;

            // Get the Task from TaskDetails
            Task objTask = (Task)objTaskDetailsModel.CurrentTask;

            return objTask;
        }
        #endregion

        // Properties

        #region CurrentTaskID
        private int _CurrentTaskID = -1;
        public int CurrentTaskID
        {
            get { return _CurrentTaskID; }
            private set
            {
                if (CurrentTaskID == value)
                {
                    return;
                }
                _CurrentTaskID = value;
                this.NotifyPropertyChanged("CurrentTaskID");
            }
        }
        #endregion

        #region Message
        private List<string> _Message = new List<string>();
        public List<string> Message
        {
            get { return _Message; }
            private set
            {
                if (Message == value)
                {
                    return;
                }
                _Message = value;
                this.NotifyPropertyChanged("Message");
            }
        }
        #endregion

        #region MessageVisibility
        private Visibility _MessageVisibility = Visibility.Collapsed;
        public Visibility MessageVisibility
        {
            get { return _MessageVisibility; }
            private set
            {
                if (MessageVisibility == value)
                {
                    return;
                }
                _MessageVisibility = value;
                this.NotifyPropertyChanged("MessageVisibility");
            }
        }
        #endregion

        // Collections

        #region colTabItems
        private ObservableCollection<TabItem> _colTabItems
            = new ObservableCollection<TabItem>();
        public ObservableCollection<TabItem> colTabItems
        {
            get { return _colTabItems; }
            private set
            {
                if (colTabItems == value)
                {
                    return;
                }
                _colTabItems = value;
                this.NotifyPropertyChanged("colTabItems");
            }
        }
        #endregion

        #region INotifyPropertyChanged
        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }
        #endregion
    }
}