public async Task <SshCommand> RunCommandAsync(string command, ConnectionUser user)
        {
            SshClient ssh;

            switch (user)
            {
            case ConnectionUser.Admin:
                ssh = m_sshAdminClient;
                break;

            case ConnectionUser.LvUser:
                ssh = m_sshUserClient;
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(user), user, null);
            }
            var  settings = SettingsProvider.ExtensionSettingsPage;
            bool verbose  = settings.Verbose || settings.DebugMode;

            if (verbose)
            {
                await OutputWriter.Instance.WriteLineAsync($"Running command: {command}").ConfigureAwait(false);
            }
            return(await Task.Run(() => ssh.RunCommand(command)).ConfigureAwait(false));
        }
Exemple #2
0
        private void ButtonGolden_Click(object sender, RoutedEventArgs e)
        {
            int result = client.CanIBecomeGolden(ConnectionUser.Instance().CurrentUser);

            if (result == 0)
            {
                MessageBox.Show("You dont have enough rented vehicles, you need to rent at least 5 vehicles");
            }
            else if (result == 1)
            {
                MessageBox.Show("You as golden member to become a regular member have to return some vehicles");
            }
            else if (result == 2)
            {
                MessageBox.Show("You have succesfully send request to become regular member");
            }
            else if (result == 3)
            {
                MessageBox.Show("You have succesfully send request to become golden member");
            }
            else
            {
                MessageBox.Show("You have already sent request");
            }
        }
Exemple #3
0
        internal static async Task <string> AddOrReplaceGroupAsync(this ConnectionUser connectionUser,
                                                                   IGroupManager grops, int groupId, HubGroupTypes groupType, string nativeName, HubGroupPrefix prefix)
        {
            var name = CreateGroupName(groupId, groupType, prefix);

            return(await connectionUser._addOrReplaceGroupAsync(grops, groupId, name, groupType, nativeName));
        }
Exemple #4
0
        /// <summary>
        ///     при удалении конрневой альянсовой группы удаляет все  дочерние группы
        /// </summary>
        /// <param name="connectionUser"></param>
        /// <param name="grops"></param>
        /// <returns></returns>
        internal static async Task <string> RemoveAllianceGroupNameAsync(this ConnectionUser connectionUser,
                                                                         IGroupManager grops)
        {
            await connectionUser.RemoveAllianceRecrutManagerGroupNameAsync(grops);

            return(await connectionUser._removeGroupAsync(grops, CreateAllianceGroupName, connectionUser.AllianceId));
        }
        public async Task <bool> DeployFileAsync(Stream file, string deployLocation, ConnectionUser user)
        {
            ScpClient scp;

            switch (user)
            {
            case ConnectionUser.Admin:
                scp = m_scpAdminClient;
                break;

            case ConnectionUser.LvUser:
                scp = m_scpUserClient;
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(user), user, null);
            }

            var  settings = SettingsProvider.ExtensionSettingsPage;
            bool verbose  = settings.Verbose || settings.DebugMode;

            if (verbose)
            {
                await OutputWriter.Instance.WriteLineAsync($"Deploying File: {deployLocation}").ConfigureAwait(false);
            }
            await Task.Run(() => scp.Upload(file, deployLocation)).ConfigureAwait(false);

            return(true);
        }
        public async Task <ActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = new ConnectionUser {
                    UserName = model.Email, Email = model.Email
                };
                var result = await UserManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                    // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
                    // Send an email with this link
                    // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
                    // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                    // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");

                    return(RedirectToAction("Index", "Home"));
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
Exemple #7
0
 // ReSharper disable once InconsistentNaming
 /// <summary>
 /// </summary>
 /// <param name="connectionUser"></param>
 /// <param name="new_alliance_user_Id">Id  в таблицы alliance_user</param>
 /// <param name="newAllianceName"></param>
 /// <param name="newAllianceRoleId"></param>
 /// <param name="newAlianceId"></param>
 internal static void SetNewAllianceData(this ConnectionUser connectionUser, int new_alliance_user_Id,
                                         string newAllianceName, byte newAllianceRoleId, int newAlianceId)
 {
     connectionUser.AllianceUserId = new_alliance_user_Id;
     connectionUser.AllianceName   = newAllianceName;
     connectionUser.AllianceRoleId = newAllianceRoleId;
     connectionUser.AllianceId     = newAlianceId;
 }
Exemple #8
0
 internal static async Task <string> AddOrReplaceGroupChannelGroupNameAsync(this ConnectionUser connectionUser,
                                                                            IGroupManager grops, int channelId, string channelNativeName)
 {
     return
         (await
          connectionUser.AddOrReplaceGroupAsync(grops, channelId, HubGroupTypes.Channel, channelNativeName,
                                                HubGroupPrefix.Group));
 }
Exemple #9
0
 internal static async Task <string> AddOrReplacePrivateChannelGroupNameAsync(this ConnectionUser connectionUser,
                                                                              IGroupManager grops, int channelId)
 {
     return
         (await
          connectionUser.AddOrReplaceGroupAsync(grops, channelId, HubGroupTypes.Channel, "",
                                                HubGroupPrefix.Private));
 }
Exemple #10
0
        private static async Task <string> _addOrReplaceGroupAsync(this ConnectionUser connectionUser,
                                                                   IGroupManager groups, int groupId, string groupName, HubGroupTypes groupType, string nativeName)
        {
            await groups.AddToGroupAsync(connectionUser.ConnectionId, groupName);

            connectionUser.Groups[groupName] = new HubGroupItem(groupId, (byte)groupType, nativeName, groupName);
            return(groupName);
        }
Exemple #11
0
        internal static IHubGroupItem GetUserChannelGroup(this ConnectionUser connectionUser, int channelId)
        {
            var channelGroup = (byte)HubGroupTypes.Channel;
            var item         = connectionUser.Groups.Values.FirstOrDefault(i =>
                                                                           i.GroupId == channelId && i.GroupType == channelGroup);

            return(item);
        }
Exemple #12
0
        public RegularViewModel(RegularView viewParam, NetTcpBinding binding, EndpointAddress address, string endDate)
        {
            this.RentVehicleCommand = new RentVehicleCommand(this, binding, address, endDate, viewParam);

            WCFClient client = new WCFClient(binding, address, ConnectionUser.Instance().CurrentUser.Username);

            List = client.ReturnVehicle(1);
        }
 public ConnectionUser AddOrUpdateLocal(ConnectionUser dataModel, bool dataIsCheked)
 {
     if (!dataIsCheked && string.IsNullOrWhiteSpace(dataModel?.ConnectionId))
     {
         return(null);
     }
     return(_users.AddOrUpdateLazy(dataModel.ConnectionId, key => dataModel, (key, oldValue) => dataModel));
 }
Exemple #14
0
        public AdminView()
        {
            InitializeComponent();

            SetProxy();

            client           = new WCFClient(binding, address, ConnectionUser.Instance().CurrentUser.Username);
            this.DataContext = new AdminViewModel(this, binding, address);
        }
 // ReSharper disable once SuggestBaseTypeForParameter
 public void SetUserData(IDbConnection connection, IAllianceService allianceService, AllianceUserDataModel adm, ConnectionUser newCurrentConnectionUser)
 {
     NewCurrentConnectionUser = newCurrentConnectionUser;
     IsCurrentUser            = true;
     if (NewRole.AcceptNewMembers)
     {
         AllianceUserRequests = allianceService.GetAllianceUserRequests(connection, adm, NewRole);
     }
 }
        private AllianceUserDataModel _getAllianceUser(IDbConnection connection, ConnectionUser user)
        {
            var au = _allianceService.GetAllianceUserById(connection, user.AllianceUserId);

            if (au.UserId == user.UserId)
            {
                return(au);
            }
            throw new HubException(Error.NotPermitted);
        }
Exemple #17
0
        private async Task _cleanDisconnectedUserData(ConnectionUser disconnectedUser, Exception exception)
        {
            _gameRunner.OnDisonnected(disconnectedUser.ConnectionId, disconnectedUser.UserId);
            disconnectedUser.Connected = false;
            await disconnectedUser.RemoveUserFromAllHubGroups(Groups);

            await Clients.Others.InvokeAsync("userLeftGame", disconnectedUser);

            _removeUserFromStorage(disconnectedUser.ConnectionId);
            await base.OnDisconnectedAsync(exception);
        }
Exemple #18
0
        public AdminViewModel(AdminView viewParam, NetTcpBinding binding, EndpointAddress address)
        {
            this.ChangeGoldenCommand  = new ChangeGoldenCommand(this, binding, address);
            this.DeleteVehicleCommand = new DeleteVehicleCommand(this, binding, address);
            this.EditVehicleCommand   = new EditVehicleCommand(this, binding, address, viewParam);

            WCFClient client = new WCFClient(binding, address, ConnectionUser.Instance().CurrentUser.Username);

            List        = client.ReturnVehicle(0);
            ListRequest = client.ReturnRequest();
        }
Exemple #19
0
        public RegularView()
        {
            InitializeComponent();

            SetProxy();
            client = new WCFClient(binding, address, ConnectionUser.Instance().CurrentUser.Username);

            this.DataContext = new RegularViewModel(this, binding, address, endDate);

            int result = client.ReturnBill(ConnectionUser.Instance().CurrentUser);

            billTextBox.Text = result.ToString();
        }
Exemple #20
0
        internal static async Task RemoveUserFromAllHubGroups(this ConnectionUser connectionUser, IGroupManager groups)
        {
            var cGroups = connectionUser.Groups.Keys.ToList();

            foreach (var key in cGroups)
            {
                await groups.RemoveFromGroupAsync(connectionUser.ConnectionId, key);

                connectionUser.Groups.Remove(key);
            }
            //    connectionUser.Groups = null;
            //  connectionUser.Groups = new Dictionary<string, IHubGroupItem>();
        }
Exemple #21
0
        protected void Page_Load(object sender, EventArgs e)
        {
            if (Request.OneAllTokenExists())
            {
                // TODO: Implement your post login logic as below

                Guid oneAllUserToken = Guid.Empty;
                Guid oneAllCnToken   = Request.OneAllToken();

                Response <ConnectionDetail> responseCn = OneAllAPI.Default.ConnectionReadDetails(oneAllCnToken);
                if (responseCn != null && responseCn.Result != null && responseCn.Result.Data != null)
                {
                    ConnectionUser oneAllCnUser = responseCn.Result.Data.User;
                    if (oneAllCnUser != null)
                    {
                        oneAllUserToken = oneAllCnUser.UserToken;
                    }
                }
                else if (responseCn != null && responseCn.Request != null && responseCn.Request.Status != null)
                {
                    _labelMessages.Text = string.Format("{0}: {1}: {2}", responseCn.Request.Status.Code, responseCn.Request.Status.Indicator, responseCn.Request.Status.Info);
                }

                if (!Guid.Empty.Equals(oneAllUserToken))
                {
                    Response <UserResult> responseUser = OneAllAPI.Default.UserReadDetails(oneAllUserToken);
                    if (responseUser != null && responseUser.Result != null && responseUser.Result.Data != null)
                    {
                        User oneAllUser = responseUser.Result.Data.User;
                        if (oneAllUser != null && oneAllUser.Identities != null && oneAllUser.Identities[0] != null)
                        {
                            Identity oneAllId = oneAllUser.Identities[0];
                            if (oneAllId != null)
                            {
                                _labelSocialName.Text = oneAllId.DisplayName;
                                if (oneAllId.ThumbnailUrl != null)
                                {
                                    _imageSocialThum.ImageUrl = oneAllId.ThumbnailUrl.ToString();
                                }
                            }
                        }
                    }
                    else if (responseUser != null && responseUser.Request != null && responseUser.Request.Status != null)
                    {
                        _labelMessages.Text = string.Format("{0}: {1}: {2}", responseUser.Request.Status.Code, responseUser.Request.Status.Indicator, responseUser.Request.Status.Info);
                    }
                }
            }
        }
Exemple #22
0
        internal static async Task UpdateAllianceGroupsByPermitionsAsync(this ConnectionUser connectionUser,
                                                                         IGroupManager groups, AllianceRoleDataModel oldUserRole, AllianceRoleDataModel newRole)
        {
            if (oldUserRole.AcceptNewMembers != newRole.AcceptNewMembers)
            {
                if (newRole.AcceptNewMembers)
                {
                    await connectionUser.AddOrReplaceAllianceRecrutManagerGroupAsync(groups);
                }
                else
                {
                    await connectionUser.RemoveAllianceRecrutManagerGroupNameAsync(groups);
                }
            }


            //todo удалить если не потребуется
            //не удалять коменты!
            //if (oldUserRole.CanManagePermition !=  newRole.CanManagePermition)
            //{
            //    //todo  если пявится группа  только для менеджеров
            //}
            //if (oldUserRole.DeleteMembers != newRole.DeleteMembers)
            //{
            //    //todo  если пявится группа
            //}
            //if (oldUserRole.EditAllianceInfo != newRole.EditAllianceInfo)
            //{
            //    //todo  если пявится группа

            //}
            //if (oldUserRole.MessageRead != newRole.MessageRead)
            //{
            //    //todo  когда пявится группа
            //}
            //if (oldUserRole.MessageSend != newRole.MessageSend)
            //{
            //    //todo  когда пявится группа

            //}
            //if (oldUserRole.SetTech != newRole.SetTech)
            //{
            //    //todo  если пявится группа
            //}
            //if (oldUserRole.ShowManage != newRole.ShowManage)
            //{
            //    //todo  если пявится группа
            //}
        }
Exemple #23
0
        private static async Task <string> _removeGroupAsync(this ConnectionUser connectionUser, IGroupManager grops,
                                                             Func <int, string> createName, int groupId)
        {
            var groupName = createName(groupId);

            if (!connectionUser.Groups.ContainsKey(groupName))
            {
                return(groupName);
            }

            connectionUser.Groups.Remove(groupName);
            await grops.RemoveFromGroupAsync(connectionUser.ConnectionId, groupName);

            return(groupName);
        }
Exemple #24
0
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            bool logout = client.LogOut(ConnectionUser.Instance().CurrentUser);

            if (logout)
            {
                ConnectionUser.Instance().CurrentUser = null;
                MainWindow main = new MainWindow();
                this.Close();
                main.ShowDialog();
            }
            else
            {
                MessageBox.Show("You have to LogIn first to LogOut");
            }
        }
Exemple #25
0
        public void Add(string connectionId, ConnectionUser connUser)
        {
            lock (_connections)
            {
                ConnectionUser user;

                if (!_connections.TryGetValue(connectionId, out user))
                {
                    _connections.Add(connectionId, connUser);
                }
                else
                {
                    //overwrite the username for that connection
                    _connections[connectionId] = user;
                }
            }
        }
Exemple #26
0
        internal static bool GetVoteRegistred(this ConnectionUser connectionUser)
        {
            if (!connectionUser.AdvancedData.ContainsKey(CuAdvancedDataKeys.RegistratedInVote))
            {
                return(false);
            }
            var registred = connectionUser.AdvancedData[CuAdvancedDataKeys.RegistratedInVote];

            if (registred == null)
            {
                return(false);
            }
            if (registred is bool)
            {
                return((bool)registred);
            }
            throw new NotImplementedException();
        }
Exemple #27
0
        internal static bool GetVoteSended(this ConnectionUser connectionUser)
        {
            if (!connectionUser.AdvancedData.ContainsKey(CuAdvancedDataKeys.VoteSended))
            {
                return(false);
            }
            var vote = connectionUser.AdvancedData[CuAdvancedDataKeys.VoteSended];

            if (vote == null)
            {
                return(false);
            }
            if (vote is bool)
            {
                return((bool)vote);
            }
            throw new NotImplementedException();
        }
        public void Execute(object parameter)
        {
            if (viewModel.Selected == null)
            {
                return;
            }

            WCFClient client = new WCFClient(binding, address, ConnectionUser.Instance().CurrentUser.Username);

            bool result = client.EditVehicle(view.nameTextBox.Text, view.modelTextBox.Text, Convert.ToInt32(view.yearTextBox.Text), Convert.ToInt32(view.priceTextBox.Text), Convert.ToInt32(view.cenaTextBox.Text), viewModel.Selected);

            if (result)
            {
                MessageBox.Show("You have succesfully edited vehicle");
                viewModel.List = client.ReturnVehicle(0);
            }
            else
            {
                MessageBox.Show("Vehicle is not avalible");
            }
        }
Exemple #29
0
        public void Execute(object parameter)
        {
            if (viewModel.SelectedRequest == null)
            {
                return;
            }

            WCFClient client = new WCFClient(binding, address, ConnectionUser.Instance().CurrentUser.Username);

            bool result = client.DoRequest(viewModel.SelectedRequest);

            if (result)
            {
                MessageBox.Show("You have succesfully change users golden membership");
                viewModel.ListRequest = client.ReturnRequest();
            }
            else
            {
                MessageBox.Show("Error");
            }
        }
        public void Execute(object parameter)
        {
            if (viewModel.Selected == null)
            {
                return;
            }

            WCFClient client = new WCFClient(binding, address, ConnectionUser.Instance().CurrentUser.Username);

            bool result = client.DeleteVehicle(viewModel.Selected);

            if (result)
            {
                MessageBox.Show("You have succesfully deleted vehicle");
                viewModel.List = client.ReturnVehicle(0);
            }
            else
            {
                MessageBox.Show("Vehicle is not avalible");
            }
        }
        public static async Task<bool> DeployFiles(IEnumerable files, string deployLocation, ConnectionUser user)
        {
            ConnectionInfo connectionInfo;
            switch (user)
            {
                case ConnectionUser.Admin:
                    connectionInfo = s_adminConnectionInfo;
                    break;
                case ConnectionUser.LvUser:
                    connectionInfo = s_lvUserConnectionInfo;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(user), user, null);
            }

            if (connectionInfo == null) return false;
            using (ScpClient scp = new ScpClient(connectionInfo))
            {
                try
                {
                    await Task.Run(() => scp.Connect());
                }
                catch (SshOperationTimeoutException)
                {
                    return false;
                }
                var settings = (SettingsPageGrid)Frc_ExtensionPackage.Instance.PublicGetDialogPage(typeof(SettingsPageGrid));
                bool verbose = settings.Verbose || settings.DebugMode;
                foreach (FileInfo fileInfo in from string s in files where File.Exists(s) select new FileInfo(s))
                {
                    if (verbose)
                    {
                        OutputWriter.Instance.WriteLine($"Deploying File: {fileInfo.Name}");
                    }
                    await Task.Run(() => scp.Upload(fileInfo, deployLocation));
                }
            }
            return true;
        }
        public static async Task<SshCommand> RunCommand(string command, ConnectionUser user)
        {
            ConnectionInfo connectionInfo;
            switch (user)
            {
                case ConnectionUser.Admin:
                    connectionInfo = s_adminConnectionInfo;
                    break;
                case ConnectionUser.LvUser:
                    connectionInfo = s_lvUserConnectionInfo;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(user), user, null);
            }

            using (SshClient ssh = new SshClient(connectionInfo))
            {
                try
                {
                    await Task.Run(() => ssh.Connect());
                }
                catch (SshOperationTimeoutException)
                {
                    return null;
                }
                var settings = (SettingsPageGrid)Frc_ExtensionPackage.Instance.PublicGetDialogPage(typeof(SettingsPageGrid));
                bool verbose = settings.Verbose || settings.DebugMode;
                if (verbose)
                {
                    OutputWriter.Instance.WriteLine($"Running command: {command}");
                }
                return await Task.Run(() => ssh.RunCommand(command));
            }
        }
        public static async Task<Dictionary<string, SshCommand>> RunCommands(string[] commands, ConnectionUser user)
        {
            ConnectionInfo connectionInfo;
            switch (user)
            {
                case ConnectionUser.Admin:
                    connectionInfo = s_adminConnectionInfo;
                    break;
                case ConnectionUser.LvUser:
                    connectionInfo = s_lvUserConnectionInfo;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(user), user, null);
            }

            Dictionary<string, SshCommand> retCommands = new Dictionary<string, SshCommand>();
            using (SshClient ssh = new SshClient(connectionInfo))
            {
                try
                {
                    await Task.Run(() => ssh.Connect());
                }
                catch (SshOperationTimeoutException)
                {
                    return null;
                }
                var settings = (SettingsPageGrid)Frc_ExtensionPackage.Instance.PublicGetDialogPage(typeof(SettingsPageGrid));
                bool verbose = settings.Verbose || settings.DebugMode;
                foreach (string s in commands)
                {
                    if (verbose)
                    {
                        OutputWriter.Instance.WriteLine($"Running command: {s}");
                    }
                    await Task.Run(() =>
                    {
                        var x = ssh.RunCommand(s);

                        retCommands.Add(s, x);
                    });
                }
            }
            return retCommands;
        }