public IssueTrackingControl(Issue issue)
        {
            // Required to initialize variables
            InitializeComponent();
            mIssue = issue;
            ViewModel = new IssueTrackingViewModel(mIssue) {View = this};

            ViewModel.DataLoaded += () =>
            {
                DataContext = ViewModel;

                if (ControlLoaded != null)
                {
                    ControlLoaded();
                }

                Loaded += (s, a) =>
                {
                    ViewModel.RaisePropertyChanged("Ranking");

                    Utils.ResetOriginalValues(this);
                    Utils.SetUpChangeEvents(this, EventAggregator, mIssue);
                };
            };
        }

 public CategoriesPicker(Issue issue)
 {
     InitializeComponent();
     mCategoryPickerModel = new CategoryPickerModel(issue);
     mCategoryPickerModel.View = this;
     DataContext = mCategoryPickerModel;
 }

        public IssueFilesViewModel(Issue issue)
        {
            CompositionInitializer.SatisfyImports(this);
            mIssue = issue;

            var cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
            cmsWebServiceClient.GetAttachmentTypesCompleted += (s, e) =>
            {
                mAttachmentTypes = e.Result;

                cmsWebServiceClient.GetIssueFilesCompleted += (s1, e1) =>
                {
                    mIssue.IssueFiles.Clear();
                    foreach (IssueFile attachment in e1.Result)
                    {
                        attachment.Issue = mIssue;//this brings i the distribution list we need to set padlock.
                        attachment.AttachmentTypes = mAttachmentTypes;
                        mIssue.IssueFiles.Add(attachment);
                    }

                    if (DataLoaded != null)
                    {
                        DataLoaded();
                    }

                    RaisePropertyChanged("Attachments");
                };
                cmsWebServiceClient.GetIssueFilesAsync(mIssue.Id);
            };
            cmsWebServiceClient.GetAttachmentTypesAsync();

            AddButton = new DelegateCommand<object>(AddButtonHandler, CanAddHandler);
            DeleteButton = new DelegateCommand<object>(DeleteButtonHandler, CanDeleteHandler);
            ExportButton = new DelegateCommand<object>(ExportButtonHandler, x => true);
        }

        public IssueControlViewModel(Issue issue, IssueControl view)
        {
            CompositionInitializer.SatisfyImports(this);
            mIssue = issue;
            View = view;
            mOriginalStatusId = mIssue.IssueStatusId;

            BuildClassificationsListBasedOnSelectedIssueType();
            GetIssueSubTypes();
            CategoriesPickerButton = new DelegateCommand<object>(CategoriesPickerButtonHandler, CanClickCategoriesButtonHandler);
            PromptCategoriesPickerButton = new DelegateCommand<object>(PromptCategoriesPickerButtonHandler, CanClickCategoriesButtonHandler);
            AreaButtonClick = new DelegateCommand<object>(AreasPickerButtonHandler, CanClickAreasButtonHandler);
            KeyStakeholdersButtonClick = new DelegateCommand<object>(KeyStakeholdersPickerButtonHandler, CanClickKeyStakeholdersButtonHandler);

            StartDateCommand = new DelegateCommand<object>(StartButtonButtonHandler, CanClickStartButtonCommand);
            EndDateCommand = new DelegateCommand<object>(EndButtonButtonHandler, CanClickEndButtonCommand);

            GetAvailableStatuses(true);

            mIssueCategories = new ObservableCollection<IssueCategory>(CMS.Cache.IssueCategories);
            mAssignedToUsers = new List<QuickUser>(CMS.Cache.ActiveUsers);
            mProjectSupervisors = new List<QuickUser>(CMS.Cache.ActiveUsers);

            //Add inactive users to the collection, if we don't it will throw javascript exception with GeneralPosition '-1,1' ...
            Utils.GetAndAddInactiverUserToList(AssignedToUsers, mIssue.CurrentlyAssignedToId);

            //Add inactive users to the collection, if we don't it will throw javascript exception with GeneralPosition '-1,1' ...
            Utils.GetAndAddInactiverUserToList(ProjectSupervisors, mIssue.ProjectSupervisorId);

            mStatuses = new List<IssueStatus>();
        }

        public IssueSystemReferencesViewModel(Issue issue)
        {
            CompositionInitializer.SatisfyImports(this);
            mIssue = issue;

            var getSystemReferencesTask = DatabaseLoader.GetSystemReferences(mIssue.Id);

            List<Task> tasks = new List<Task> {getSystemReferencesTask};

            Task.Factory.ContinueWhenAll(tasks.ToArray(), x =>
            {
                CMS.UiFactory.StartNew(() =>
                {
                    //SystemReferences
                    mIssue.SystemReferences = getSystemReferencesTask.Result;
                    mIssue.ModifiedObjects.SystemReferenceModified = true;
                    Utils.SetUpChangeEvents(View, EventAggregator, mIssue);
                    RaisePropertyChanged("SystemReferences");

                    mDictionary = Utils.BuildDictionaryForCollection(mIssue.SystemReferences.Select(r => r.Id).ToList());

                    if (DataLoaded != null) { DataLoaded(); }
                });
            });

            AddButton = new DelegateCommand<object>(AddHandler, CanAdd);
            DeleteButton = new DelegateCommand<object>(DeleteHandler, CanDelete);
            EditButton = new DelegateCommand<object>(EditHandler, CanModify);
            SelectButton = new DelegateCommand<object>(SelectHandler, CanModify);
        }

        public IssueTrackingViewModel(Issue issue)
        {
            CompositionInitializer.SatisfyImports(this);
            mIssue = issue;

            var getIssueEffordsTask = DatabaseLoader.GetIssueEffords();
            var getIssueRewardsTask = DatabaseLoader.GetIssueRewards();
            var getCalculatedRatingCoefficientsTask = DatabaseLoader.GetCalculatedRatingCoefficients();

            var tasks = new List<Task> {getIssueEffordsTask, getIssueRewardsTask, getCalculatedRatingCoefficientsTask};

            Task.Factory.ContinueWhenAll(tasks.ToArray(), x =>
            {
                CMS.UiFactory.StartNew(() =>
                {
                    mIssue.ModifiedObjects.SystemReferenceModified = true;
                    Utils.SetUpChangeEvents(View, EventAggregator, mIssue);
                    RaisePropertyChanged("SystemReferences");

                    //IssueEffords
                    mEffortList = getIssueEffordsTask.Result.OrderBy(e => e.Ordinal).ToList();

                    //IssueRewards
                    mRewardList = getIssueRewardsTask.Result.OrderBy(r => r.Ordinal).ToList();

                    //CalculatedRatingCoefficients
                    mCalculatedRatingCoefficients = getCalculatedRatingCoefficientsTask.Result;

                    if (DataLoaded != null)
                    {
                        DataLoaded();
                    }
                });
            });
        }

        public IssueSystemReferencesControl(Issue issue)
        {
            // Required to initialize variables
            InitializeComponent();
            mIssue = issue;
            ViewModel = new IssueSystemReferencesViewModel(mIssue)
            {
                View = this
            };

            ViewModel.DataLoaded += () =>
            {
                DataContext = ViewModel;

                if (ControlLoaded != null)
                {
                    ControlLoaded();
                }

                Loaded += (s, a) =>
                {

                    TelerikGrid.DataLoaded += (s1, e1) =>
                    {
                        Utils.ResetOriginalValues(TelerikGrid);
                        Utils.SetUpChangeEvents(TelerikGrid, EventAggregator, mIssue);
                    };

                    Utils.ResetOriginalValues(this);
                    Utils.SetUpChangeEvents(this, EventAggregator, mIssue);
                };
            };
        }

 public IssueRelatedOverridesControl(Issue issue)
 {
     if (DesignerProperties.IsInDesignTool) { return; }
     InitializeComponent();
     CompositionInitializer.SatisfyImports(this);
     mIssue = issue;
     Loaded += ControlLoaded;
 }

        public IssueKpiControlViewModel(Issue issue, IssueKpiControl view)
        {
            mView = view;
            mIssue = issue;
            CompositionInitializer.SatisfyImports(this);
            mTimer.Interval = TimeSpan.FromMilliseconds(500);
            mTimer.Tick += RefreshKpiTable;

            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
            IssueKpis = new List<IssueKpiTableViewModel>();

            AddButtonCommand = new DelegateCommand<object>(AddButtonHandler, CanExecuteAddButtonHandler);
            RemoveButtonCommand = new DelegateCommand<object>(RemoveButtonHandler, CanExecuteRemoveButtonHandler);
            ShowHideBaselineCommand = new DelegateCommand<object>(ShowHideBaselineHandler, x => true);

            IsBusy = true;

            cmsWebServiceClient.GetIssueKpiVarianceCodesCompleted += (s1, e1) =>
            {
                IssueKpiVarianceCodes = e1.Result;
                RaisePropertyChanged("IssueKpiVarianceCodes");

                cmsWebServiceClient.GetIssueKpisCompleted += (s, e) =>
                {
                     mIssue.IssueKpis = e.Result;

                     DatabaseLoader.GetIssueSettings().ContinueWith(getIssueFinancialSettingsTask =>
                     {
                        CMS.UiFactory.StartNew(() =>
                         {
                             mIssueSetting = getIssueFinancialSettingsTask.Result;

                             foreach (var issueKpi in mIssue.IssueKpis)
                             {
                                 var financialTableItem = new IssueKpiTableViewModel(issueKpi, IssueKpiVarianceCodes, view,
                                     CanUserModifyActuals(), mIssueSetting);
                                 mIssueKpis.Add(financialTableItem);
                             }
                             mIssueKpis = mIssueKpis.OrderBy(x => x.Date).ToList();
                             RaisePropertyChanged("IssueKpis");

                             //mDictionary = Utils.BuildDictionaryForCollection(mIssue.IssueFinancials.Select(x => x.Id).ToList());
                             mIssue.ModifiedObjects.KpisModified = true;

                             if (view.ViewModelLoaded != null)
                             {
                                 view.ViewModelLoaded();
                             }
                             IsBusy = false;
                         });
                     });

                };
                cmsWebServiceClient.GetIssueKpisAsync(mIssue.Id);

            };
            cmsWebServiceClient.GetIssueKpiVarianceCodesAsync();
        }

        public IssueRelatedDocumentControl(Issue issue)
        {
            InitializeComponent();

            CompositionInitializer.SatisfyImports(this);

            mIssue = issue;
            Loaded += ControlLoaded;
        }

        public ApprovalsControl(Issue issue)
        {
            if (DesignerProperties.IsInDesignTool) { return; }
            // Required to initialize variables
            InitializeComponent();

            mApprovalViewModel = new ApprovalViewModel(issue);
            DataContext = mApprovalViewModel;
        }

        public CloseoutControl(Issue issue)
        {
            if (DesignerProperties.IsInDesignTool) { return; }
            // Required to initialize variables
            InitializeComponent();

            mCloseoutViewModel = new CloseoutViewModel(issue);
            DataContext = mCloseoutViewModel;
        }

        public RiskReviewDialog(Issue issue, CommonUtils.RiskType riskType)
        {
            if (DesignerProperties.IsInDesignTool){return;}
            // Required to initialize variables
            InitializeComponent();

            RiskReviewDialogViewModel riskReviewDialogViewModel = new RiskReviewDialogViewModel(issue, riskType, this);
            DataContext = riskReviewDialogViewModel;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="user">Optional paramete. If not specified logged in user will be used</param>
        /// <returns></returns>
        public bool CanViewSensitiveIssues(Issue issue, User user = null)
        {
            if (user == null)
            {
                user = CMS.User;
            }

            return true;
        }

        public RiskReviewViewModel(Issue issue)
        {
            mIssue = issue;

            InitialRiskButtonClick = new DelegateCommand<object>(InitialRiskButtonClickHandler, CanModifyHandler);
            FinalRiskButtonClick = new DelegateCommand<object>(FinalRiskButtonClickHandler, CanModifyHandler);
            ExistingRiskButtonClick = new DelegateCommand<object>(ExistingRiskButtonClickHandler, CanModifyHandler);

            GetHighestRisks();
        }

        public IssueRelatedElectricalControl(Issue issue)
        {
            if (DesignerProperties.IsInDesignTool){return;}
            // Required to initialize variables

            InitializeComponent();
            CompositionInitializer.SatisfyImports(this);

            mIssue = issue;
            Loaded += ControlLoaded;
        }

        public CopyIssueOptionsModel(Issue issue)
        {
            mIssue = issue;

            BuildOptions();

            DialogTitle = string.Format("Copy of Issue #{0}", issue.Id);

            OkButtonCommand = new DelegateCommand<object>(OkButtonHander, CanExecuteOkButtonHandler);
            CancelButtonCommand = new DelegateCommand<object>(CancelButtonHander, CanExecuteOkButtonHandler);
        }

        public AddEditIssueLearningDialog(Issue issue)
        {
            InitializeComponent();

            AddEditIssueLearningModel viewModel = new AddEditIssueLearningModel(issue);
            DataContext = viewModel;

            this.Title = @"Add Learning";

            viewModel.ViewModelLoaded += () => Utils.ResetOriginalValues(this);
        }

        public IssueRelatedIssuesViewModel(Issue issue)
        {
            CompositionInitializer.SatisfyImports(this);
            mIssue = issue;
            IsBusy = true;
            CMS.UiFactory.StartNew(LoadData);

            DeleteIssueButton = new DelegateCommand<object>(DeleteIssueHandler, CanDelete);
            CreateCommand = new DelegateCommand<object>(AddRelatedIssueHandler, CanCreate);
            LinkCommand = new DelegateCommand<object>(LinkIssueButtonHandler, CanLink);
            ViewCommand = new DelegateCommand<object>(OpenIssueButtonHandler, CanView);
        }

        public IssueDistributionModel(Issue issue)
        {
            mIssue = issue;
            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
            CompositionInitializer.SatisfyImports(this);

            cmsWebServiceClient.GetIssueDistributionUsersAsync(mIssue.Id);
            cmsWebServiceClient.GetIssueDistributionUsersCompleted += (cmsWebServiceClient_GetIssueDistributionUsersCompleted);

            AddButtonCommand = new DelegateCommand<object>(AddButtonHander, CanExecuteAddButtonHandler);
            RemoveButtonCommand = new DelegateCommand<object>(RemoveButtonHander, CanExecuteDeleteButtonHandler);
        }