private void LogoutAsync()
        {
            Log.Logger.Debug("【log out by logout command】");
            IVisualizeShell visualizeShellService = IoC.Get <IVisualizeShell>();

            visualizeShellService.Logout();
        }
Example #2
0
        private async Task StartSdkAsync()
        {
            if (!_sdkService.IsServerStarted)
            {
                _sdkService.SetSdkServerPath(Path.Combine(Environment.CurrentDirectory, "sdk"));

                IVisualizeShell visualizeShellService =
                    IoC.Get <IVisualizeShell>();

                visualizeShellService.StartingSdk();

                UserInfo userInfo = IoC.Get <UserInfo>();

                AsyncCallbackMsg startResult = await _sdkService.StartServerViaAppKey(userInfo.AppKey, userInfo.OpenId,
                                                                                      userInfo.GetNube(), "http://xmeeting.butel.com/nps_x1");

                if (startResult.Status != 0)
                {
                    visualizeShellService.FinishStartingSdk(false, startResult.Message);
                }
                else
                {
                    visualizeShellService.FinishStartingSdk(true, Messages.InfoMeetingSdkStarted);
                    AsyncCallbackMsg setFillModeResult = _sdkService.SetFillMode(0);

                    HasErrorMsg(setFillModeResult.Status.ToString(), Messages.WarningSetFillModeFailed);
                }

                //Thread.Sleep(1000);
            }
        }
Example #3
0
        private void LogoutAsync()
        {
            Log.Logger.Debug("【log out by logout command】");
            IVisualizeShell visualizeShellService = DependencyResolver.Current.Container.Resolve <IVisualizeShell>();

            visualizeShellService.Logout();
        }
        private async Task StartSdkAsync()
        {
            if (!_sdkService.MeetingAgentStarted)
            {
                IVisualizeShell visualizeShellService =
                    DependencyResolver.Current.Container.Resolve <IVisualizeShell>();

                visualizeShellService.StartingSdk();

                UserInfo userInfo = DependencyResolver.Current.Container.Resolve <UserInfo>();

                StartResult startResult = await _sdkService.Start(userInfo);

                if (startResult.m_result.m_rc != 0)
                {
                    visualizeShellService.FinishStartingSdk(false, startResult.m_result.m_message);
                }
                else
                {
                    visualizeShellService.FinishStartingSdk(true, Messages.InfoMeetingSdkStarted);
                    int setFillModeResult = _sdkService.SetFillMode(0);

                    HasErrorMsg(setFillModeResult.ToString(), Messages.WarningSetFillModeFailed);
                }

                //Thread.Sleep(1000);
            }
        }
 private void MeetingService_ExitMeetingCallbackEvent(bool exitedSuccessful, string arg2)
 {
     if (exitedSuccessful)
     {
         IVisualizeShell visualizeShellService = IoC.Get <IVisualizeShell>();
         visualizeShellService.ShowShell();
     }
 }
Example #6
0
 private void MeetingService_ExitMeetingCallbackEvent(bool exitedSuccessful, string arg2)
 {
     if (exitedSuccessful)
     {
         IVisualizeShell visualizeShellService = DependencyResolver.Current.Container.Resolve <IVisualizeShell>();
         visualizeShellService.ShowShell();
     }
 }
        public async Task <ResponseResult> Request(string url, HttpContent content = null)
        {
            var bmsResult = new ResponseResult();

            using (var httpClient = new HttpClient())
            {
                httpClient.BaseAddress = new Uri(GlobalData.Instance.AggregatedConfig.GetInterfaceItem().BmsAddress);
                httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);

                HttpResponseMessage response = null;
                try
                {
                    Log.Logger.Debug($"Request => url={url}");
                    response = content == null
                        ? await httpClient.GetAsync(url)
                        : await httpClient.PostAsync(url, content);

                    Log.Logger.Debug(
                        $"HttpResponseMessage => status={response.StatusCode}, message={response.ReasonPhrase}");
                }
                catch (Exception ex)
                {
                    bmsResult.Status  = "-1";
                    bmsResult.Message = ex.Message;

                    Log.Logger.Error($"Request => {ex}");

                    return(bmsResult);
                }

                if (response.IsSuccessStatusCode)
                {
                    var result = await response.Content.ReadAsStringAsync();

                    var obj = JsonConvert.DeserializeObject(result, typeof(ResponseResult));
                    bmsResult = obj as ResponseResult;
                }
                else
                {
                    if (response.StatusCode == HttpStatusCode.Unauthorized)
                    {
                        Log.Logger.Debug($"【log out, because of timeout】:{response.StatusCode}");

                        IVisualizeShell visualizeShellService =
                            IoC.Get <IVisualizeShell>();
                        await visualizeShellService.Logout();
                    }

                    bmsResult.Message = response.ReasonPhrase;
                    bmsResult.Status  = response.StatusCode.ToString();
                }

                return(bmsResult);
            }
        }
 private void MeetingService_StartMeetingCallbackEvent(bool startedSuccessful, string msg)
 {
     if (startedSuccessful)
     {
         IVisualizeShell visualizeShellService = IoC.Get <IVisualizeShell>();
         visualizeShellService.HideShell();
     }
     else
     {
         HasErrorMsg("-1", msg);
     }
 }
Example #9
0
 private void MeetingService_StartMeetingCallbackEvent(bool startedSuccessful, string msg)
 {
     if (startedSuccessful)
     {
         IVisualizeShell visualizeShellService = DependencyResolver.Current.Container.Resolve <IVisualizeShell>();
         visualizeShellService.HideShell();
     }
     else
     {
         HasErrorMsg("-1", msg);
     }
 }
Example #10
0
        private void MeetingService_StartMeetingCallbackEvent(bool startedSuccessful, string msg)
        {
            if (startedSuccessful)
            {
                IVisualizeShell visualizeShellService = IoC.Get <IVisualizeShell>();
                visualizeShellService.HideShell();
            }
            else
            {
                GlobalData.Instance.CurWindowHwnd = _visualizeShellService.GetShellHandle();

                HasErrorMsg("-1", msg);
            }
        }
Example #11
0
        public LoginViewModel(Window loginView)
        {
            _loginView            = loginView;
            _userInfo             = DependencyResolver.Current.GetService <UserInfo>();
            _bmsService           = DependencyResolver.Current.GetService <IBms>();
            _visualizeShellSevice = DependencyResolver.Current.GetService <IVisualizeShell>();
            _loginView.Closing   += _loginView_Closing;

            LoginCommand          = DelegateCommand.FromAsyncHandler(LoginAsync);
            LoadCommand           = DelegateCommand.FromAsyncHandler(LoadAsync);
            SaveSettingCommand    = DelegateCommand.FromAsyncHandler(SaveSettingAsync);
            ShowSettingCommand    = new DelegateCommand(ShowSettingAsync);
            TopMostTriggerCommand = new DelegateCommand(TriggerTopMost);
            ShowLogCommand        = DelegateCommand.FromAsyncHandler(ShowLogAsync);
        }
        public LoginViewModel(Window loginView)
        {
            _windowManager        = IoC.Get <IMeetingWindowManager>();
            _loginView            = loginView;
            _userInfo             = IoC.Get <UserInfo>();
            _bmsService           = IoC.Get <IBms>();
            _visualizeShellSevice = IoC.Get <IVisualizeShell>();
            _loginView.Closing   += _loginView_Closing;

            LoginCommand          = DelegateCommand.FromAsyncHandler(LoginAsync);
            LoadCommand           = DelegateCommand.FromAsyncHandler(LoadAsync);
            SaveSettingCommand    = DelegateCommand.FromAsyncHandler(SaveSettingAsync);
            ShowSettingCommand    = new DelegateCommand(ShowSettingAsync);
            TopMostTriggerCommand = new DelegateCommand(TriggerTopMost);
            ShowLogCommand        = DelegateCommand.FromAsyncHandler(ShowLogAsync);
        }
Example #13
0
        private async Task StartSdkAsync()
        {
            if (!_meetingSdkAgent.IsStarted)
            {
                var path = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);

                IVisualizeShell visualizeShellService = IoC.Get <IVisualizeShell>();

                visualizeShellService.StartingSdk();


                MeetingResult result = await _meetingSdkAgent.Start("PCJM", path);


                if (result.StatusCode != 0)
                {
                    visualizeShellService.FinishStartingSdk(false, $"启动失败!{result.Message}");
                }
                else
                {
                    Common.UserInfo userInfo = IoC.Get <Common.UserInfo>();

                    MeetingResult <LoginModel> meetingResult = await _meetingSdkAgent.LoginThirdParty(userInfo.GetNube(), userInfo.AppKey, userInfo.OpenId);

                    if (meetingResult.StatusCode != 0)
                    {
                        visualizeShellService.FinishStartingSdk(false, "登录失败!");
                    }
                    else
                    {
                        _eventAggregator.GetEvent <UserLoginEvent>().Publish(new MeetingSdk.Wpf.UserInfo()
                        {
                            UserId   = meetingResult.Result.Account.AccountId,
                            UserName = userInfo.UserName,
                        });

                        visualizeShellService.FinishStartingSdk(true, Messages.InfoMeetingSdkStarted);
                    }
                }

                //Thread.Sleep(1000);
            }
        }
 public MainViewModel()
 {
     _visualizeShellService = IoC.Get <IVisualizeShell>();
 }
 public MainViewModel()
 {
     _visualizeShellService = DependencyResolver.Current.GetService <IVisualizeShell>();
 }