C# CmsWebServiceClient类代码示例

        public AddIssueSubTypeViewModel(List<IssueSubType> selectedIssueSubTypes, IEnumerable<IssueType> issueTypes)
        {
            var idList = (from x in issueTypes select x.Id).ToList();

            mSelectedSubIssueSubTypes = selectedIssueSubTypes;
            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

            cmsWebServiceClient.GetIssueSubTypesAvailableForIssueTypesCompleted += (s1, e1) =>
                                                             {
                                                                 IssueSubTypes = e1.Result.OrderBy(x=>x.Ordinal).ToList();

                                                                 foreach (var issueType in IssueSubTypes)
                                                                 {
                                                                     if ((from x in mSelectedSubIssueSubTypes where x.Id == issueType.Id select x).FirstOrDefault() != null)
                                                                     {
                                                                         issueType.Checked = true;
                                                                     }
                                                                 }
                                                                 mIssueSubTypesLoaded = true;
                                                                 RaiseLoaded();

                                                             };
            cmsWebServiceClient.GetIssueSubTypesAvailableForIssueTypesAsync(idList);

            OkButtonCommand = new DelegateCommand<object>(OkButtonHandler, CanExecuteOkButtonHandler);
            CancelButtonCommand = new DelegateCommand<object>(CanelButtonHandler, CanExecuteOkButtonHandler);
        }

        public AddEditPropertyListNameViewModel(AddEditPropertyListNameDialog view, PropertyListName propertyListName, CommonUtils.Operation operation)
        {
            View = view;
            mPropertyListName = propertyListName;

            OkButtonCommand = new DelegateCommand<object>(OkButtonHander, CanModifyConfig);
            CancelButtonCommand = new DelegateCommand<object>(CancelButtonHander, x => true);

            if (operation == CommonUtils.Operation.Update)
            {
                CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

                cmsWebServiceClient.GetPropertyListNameCompleted +=
                    (s1, e1) =>
                    {
                        mPropertyListName = e1.Result;
                        LoadPropertyListNames(mPropertyListName.PropertyListId);
                        mExistingPropertyListNamesLoaded = true;
                        FireLoaded();
                    };
                cmsWebServiceClient.GetPropertyListNameAsync(mPropertyListName.Id);
            }
            else
            {
                LoadPropertyListNames(mPropertyListName.PropertyListId);
            }
        }

        public AddEditUnitViewUnit(AddEditUnitDialog view, Unit unit, CommonUtils.Operation operation)
        {
            View = view;
            mUnit = unit;
            LoadUnits();

            OkButtonCommand = new DelegateCommand<object>(OkButtonHander, CanModifyConfig);
            CancelButtonCommand = new DelegateCommand<object>(CancelButtonHander, x => true);

            if (operation == CommonUtils.Operation.Update)
            {
                CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

                cmsWebServiceClient.GetUnitCompleted +=
                    (s1, e1) =>
                    {
                        mUnit = e1.Result;
                        FireLoaded();
                    };
                cmsWebServiceClient.GetUnitAsync(mUnit.Id);
            }
            else
            {
                FireLoaded();
            }
        }

        public AddIssueTypeViewModel(List<IssueType> selectedIssueTypes)
        {
            if (DesignerProperties.IsInDesignTool) { return; }

            mSelectedIssueTypes = selectedIssueTypes;
            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

            cmsWebServiceClient.GetIssueTypesCompleted += (s1, e1) =>
                                                             {
                                                                 IssueTypes = e1.Result;

                                                                 foreach (var issueType in IssueTypes)
                                                                 {
                                                                     if ((from x in mSelectedIssueTypes where x.Id == issueType.Id select x).FirstOrDefault() != null)
                                                                     {
                                                                         issueType.Checked = true;
                                                                     }
                                                                 }
                                                                 mIssueTypesLoaded = true;
                                                                 RaiseLoaded();

                                                             };
            cmsWebServiceClient.GetIssueTypesAsync();

            OkButtonCommand = new DelegateCommand<object>(OkButtonHandler, CanExecuteOkButtonHandler);
            CancelButtonCommand = new DelegateCommand<object>(CanelButtonHandler, CanExecuteOkButtonHandler);
        }

        public MyProfileViewModel(User user)
        {
            mUser = user;

            if (user.UserPreference == null)
            {
                const int width = 315;
                user.UserPreference = new UserPreference();
                user.UserPreference.AdminPanelWidth = width;
                user.UserPreference.ControlPanelWidth = width;
                user.UserPreference.DocumentPanelWidth = 630;
                user.UserPreference.ElectricalPanelWidth = width;
                user.UserPreference.InstrumentPanelWidth = width;
                user.UserPreference.IssuePanelWidth = width;
                user.UserPreference.MechanicalPanelWidth = width;
                user.UserPreference.MobilePanelWidth = width;
                user.UserPreference.PipePanelWidth = width;
            }

            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

            cmsWebServiceClient.UserIsADefaultUserCompleted +=
                (s1, e1) =>
                {
                    UserIsADefaultUser = e1.Result;
                };

            cmsWebServiceClient.UserIsADefaultUserAsync(mUser.Id);
        }

        public AddEditIssueFinancialVarianceCodeModel(CommonUtils.Operation operation, int itemId)
        {
            CompositionInitializer.SatisfyImports(this);

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

            if (operation == CommonUtils.Operation.Add)
            {
                mIssueFinancialVarianceCode = new IssueFinancialVarianceCode();
            }
            else if (operation == CommonUtils.Operation.Update)
            {
                var varianceId = itemId;
                CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

                cmsWebServiceClient.GetIssueFinancialVarianceCodeCompleted += (s1, e1) =>
                {
                    mIssueFinancialVarianceCode = e1.Result;
                    if (DataLoaded != null)
                    {
                        mIssueFinancialVarianceCode = e1.Result;
                        DataLoaded();
                    }
                };
                cmsWebServiceClient.GetIssueFinancialVarianceCodeAsync(varianceId);
            }
        }

        private void OKButton_Click(object sender, RoutedEventArgs e)
        {
            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
            cmsWebServiceClient.EmptyReportsFolderCompleted += cmsWebServiceClient_EmptyReportsFolderCompleted;

            cmsWebServiceClient.EmptyReportsFolderAsync(CMS.AppSetting.DownloadAttachmentsPathRoot);
        }

        public AddEditCoefficientModel(CommonUtils.Operation operation, int itemId)
        {
            CompositionInitializer.SatisfyImports(this);

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

            if (operation == CommonUtils.Operation.Add)
            {
                var groupId = itemId;
                mCoefficient = new CalculatedRatingCoefficient();
                //mCoefficient.CoefficientGroupId = groupId;
            }
            else if (operation == CommonUtils.Operation.Update)
            {
                var CoefficientId = itemId;
                CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

                cmsWebServiceClient.GetCalculatedRatingCoefficientCompleted += (s1, e1) =>
                {
                    mCoefficient = e1.Result;
                    if (DataLoaded != null)
                    {
                        mCoefficient = e1.Result;
                        DataLoaded();
                    }
                };
                cmsWebServiceClient.GetCalculatedRatingCoefficientAsync(CoefficientId);
            }
        }

        public MobilePlantControlViewModel(int equipmentId)
        {
            CompositionInitializer.SatisfyImports(this);

            SaveButtonCommand = new DelegateCommand<object>(SaveButtonHandler, CanModify);
            RemoveButtonCommand = new DelegateCommand<object>(RemoveButtonHandler, CanDelete);
            ExpiryPickerButton = new DelegateCommand<object>(ExpiryButtonHandler, CanDelete);

            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

            cmsWebServiceClient.GetMobilePlantCompleted += cmsWebServiceClient_GetMobilePlantCompleted;
            cmsWebServiceClient.GetMobilePlantAsync(equipmentId);

            cmsWebServiceClient.GetMobilePlantTypesCompleted += cmsWebServiceClient_GetMobilePlantTypesCompleted;
            cmsWebServiceClient.GetMobilePlantTypesAsync(false);

            //MobileHirers
            cmsWebServiceClient.GetMobileHirersCompleted += cmsWebServiceClient_GetMobileHirersCompleted;
            cmsWebServiceClient.GetMobileHirersAsync();

            //Owners
            cmsWebServiceClient.GetMobileOwnersCompleted += cmsWebServiceClient_GetMobileOwnersCompleted;
            cmsWebServiceClient.GetMobileOwnersAsync();

            cmsWebServiceClient.GetUpperEquipmentsCompleted += cmsWebServiceClient_GetUpperEquipmentsCompleted;
            cmsWebServiceClient.GetUpperEquipmentsAsync();

            Areas = new ObservableCollection<Area>(from x in CMS.Cache.Areas where x.IsActive && x.SiteId == CMS.AppSetting.DefaultSiteId select x);
        }

        private void GetDomainUsers()
        {
            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

            EventHandler<GetActiveDirectoryUsersCompletedEventArgs> eventHandler = null;
            eventHandler =
               (s1, e1) =>
               {
                   var activeDirectoryContacts = e1.Result;
                   UsersDataGrid.ItemsSource = activeDirectoryContacts;
                   cmsWebServiceClient.GetActiveDirectoryUsersCompleted -= eventHandler;

                   //sort by Contact column
                   UsersDataGrid.SortDescriptors.Clear();
                   ColumnSortDescriptor descriptor = new ColumnSortDescriptor();
                   descriptor.Column = (GridViewDataColumn)UsersDataGrid.Columns["Contact"];
                   descriptor.SortDirection = ListSortDirection.Ascending;
                   UsersDataGrid.SortDescriptors.Add(descriptor);

                   IsBusyIndicator.IsBusy = false;

               };
            cmsWebServiceClient.GetActiveDirectoryUsersCompleted += eventHandler;
            cmsWebServiceClient.GetActiveDirectoryUsersAsync();
        }

        public AddEditExistingControlSystemComponentAlarmPropertyViewModel(int componentTypePropertyId)
        {
            //edit

            OkButtonCommand = new DelegateCommand<object>(OkButtonHander, CanModify);
            CancelButtonCommand = new DelegateCommand<object>(CancelButtonHander, x => true);

            CmsWebServiceClient cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
            Properties = new List<ControlSystemAlarmProperty>();

            //Load ControlSystem Properties types
            EventHandler<GetAllControlSystemAlarmPropertiesCompletedEventArgs>
                fetchCompleted = (s, e) =>
                                     {
                                         Properties = e.Result;
                                         cmsWebServiceClient.GetControlSystemComponentTypeAlarmPropertyCompleted +=
                                             (s2, e2) =>
                                             {
                                                 if (Properties.Count > 0)
                                                 {
                                                     SelectedProperty = (from x in Properties
                                                                         where x.Id == e2.Result.ComponentTypeId
                                                                         select x).FirstOrDefault();
                                                 }

                                                 mControlSystemComponentTypeAlarmProperty = e2.Result;
                                                 Loaded();
                                             };
                                         cmsWebServiceClient.GetControlSystemComponentTypeAlarmPropertyAsync(componentTypePropertyId);
                                     };

            cmsWebServiceClient.GetAllControlSystemAlarmPropertiesCompleted += fetchCompleted;
            cmsWebServiceClient.GetAllControlSystemAlarmPropertiesAsync();
        }

        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 AddClassificationViewModel(List<IssueClassification> selectedIssueSubTypes, IEnumerable<IssueType> issueTypes)
        {
            mSelectedClassifications = selectedIssueSubTypes;

            var ids = (from x in issueTypes select x.Id).ToList();

            var cmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);
            cmsWebServiceClient.GetIssueClassificationsAvailableForIssueTypesCompleted += (s1, e1) =>
            {
                IssueClassifications = e1.Result;

                foreach (IssueClassification classification in IssueClassifications)
                {
                    if ((from x in mSelectedClassifications where x.Id == classification.Id select x).FirstOrDefault() != null)
                    {
                        classification.Checked = true;
                    }
                }
                mLoaded = true;
                RaiseLoaded();
            };
            cmsWebServiceClient.GetIssueClassificationsAvailableForIssueTypesAsync(ids);

            OkButtonCommand = new DelegateCommand<object>(OkButtonHandler, CanExecuteOkButtonHandler);
            CancelButtonCommand = new DelegateCommand<object>(CanelButtonHandler, CanExecuteOkButtonHandler);
        }

        public static Task LoadIssueCategoriesCache()
        {
            var task = new TaskCompletionSource<bool>();

            if (CMS.Cache.IssueCategories == null)
            {
                CMS.Cache.IssueCategories = new CmsObservableCollection<IssueCategory>();
                var cee = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

                DateTime now = DateTime.Now;
                System.Diagnostics.Debug.WriteLine("LoadIssueCategoriesCache First {0}", now.ToString("G"));

                //IssueCategories
                cee.GetIssueCategoriesCompleted += (s4, e4) =>
                {
                    CMS.Cache.IssueCategories = new ObservableCollection<IssueCategory>(e4.Result.OrderBy(x => x.Ordinal));
                    var elapsed = DateTime.Now - now;
                    System.Diagnostics.Debug.WriteLine("LoadIssueCategoriesCache: {0}      {1}", elapsed.TotalSeconds, DateTime.Now);
                    task.SetResult(true);
                };
                cee.GetIssueCategoriesAsync();
            }
            else
            {
                task.SetResult(true);
                return task.Task; //Already loaded
            }
            return task.Task;
        }

        public AddControlSystemRevisionHistoryDialog(int controlSystemId, string tabText)
        {
            InitializeComponent();
            mHistory.IsSystemMessage = false;

            this.Title = string.Format("Add Revision History - Control System {0}: " , tabText);

            mHistory.ControlSystemId = controlSystemId;
            mModel = new ControlSystemRevisionHistoryViewModel(mHistory);

            DataContext = mModel;

            CmsWebServiceClient mCmsWebServiceClient = new CmsWebServiceClient(Utils.WcfBinding, Utils.WcfEndPoint);

            mCmsWebServiceClient.GetControlSystemRelatedIssuesCompleted +=
                (s1, e1) =>
                    {
                        //Get list of issue ids assigned to the pipe
                        List<IssueRelatedControlSystem> relatedIssues = e1.Result;
                        List<int> issueIds = (from x in relatedIssues select x.IssueId).ToList();

                        mCmsWebServiceClient.GetIssuesAsync(issueIds);

                        mCmsWebServiceClient.GetIssuesCompleted +=
                            (s2, e2) =>
                                {
                                    //Bing list of issues to IssuesGridView
                                    issueComboBox.ItemsSource = e2.Result;
                                };
                    };

            mCmsWebServiceClient.GetControlSystemRelatedIssuesAsync(controlSystemId);
        }