public IActionResult DeleteAccounts(int id, ServerAccountModel serverAccount)
        {
            // Vérification de l'appelant
            if (!this.SecurityCheckRoleAdminOrOwner(serverAccount.UserLogin))
            {
                return(Forbid());
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id < 0 || string.IsNullOrWhiteSpace(serverAccount.UserLogin))
            {
                return(BadRequest());
            }

            if (id != serverAccount.ServerId)
            {
                return(BadRequest());
            }
            DatabaseServerUser databaseServerUser = _service.RemoveAccount(id, serverAccount.UserLogin);

            if (databaseServerUser == null)
            {
                return(NotFound());
            }

            return(Ok(databaseServerUser));
        }
        public void TestGetOneAccount()
        {
            string             login = "******";
            DatabaseServerUser databaseServerUser = service.GetAccountByServerLogin(0, login);

            Assert.IsNotNull(databaseServerUser);
            Assert.IsTrue(databaseServerUser.UserLogin.Equals(login, StringComparison.InvariantCultureIgnoreCase));
            Assert.IsNotNull(databaseServerUser.SqlLogin);
        }
        public DatabaseServerUser RemoveAccount(int serverId, string userLogin)
        {
            DatabaseServerUser databaseServerUser = null;
            DatabaseServerName databaseServerName = null;
            string             serverName         = "Serveur non trouvé";

            try
            {
                // Obtention du serveur
                databaseServerName = this.db.DatabaseServerName.Find(serverId);
                if (databaseServerName == null)
                {
                    return(null);
                }
                serverName = databaseServerName.Name;
            }
            catch (Exception ex)
            {
                LogManager.GetLogger().Error(ex);
                throw new DatabaseException(String.Format("Erreur dans l'obtention du compte utilisateur {0} du serveur '{1}' dans le référentiel, Erreur: {2}", userLogin, serverName, ex.Message));
            }

            try
            {
                var databaseServerUsers = db.DatabaseServerUser.Include(su => su.Server).AsEnumerable();
                databaseServerUser = databaseServerUsers.SingleOrDefault(su => su.ServerId == serverId && su.UserLogin.Equals(userLogin, StringComparison.InvariantCultureIgnoreCase));
                if (databaseServerUser == null)
                {
                    return(null);
                }

                db.DatabaseServerUser.Remove(databaseServerUser);
                db.SaveChanges();
            }
            catch (Exception ex)
            {
                LogManager.GetLogger().Error(ex);
                throw new DatabaseException(String.Format("Erreur dans la suppression du compte utilisateur {0} sur le serveur '{1}' dans le référentiel, Erreur: {2}", userLogin, serverName, ex.Message));
            }

            try
            {
                // Obtention du serveur réel : MySQL, SQL Server, ... avec son adresse IP
                DatabaseManagement management = DatabaseManagement.CreateDatabaseManagement(databaseServerName.Code, databaseServerName.Iplocale, databaseServerName.PortLocal);
                // Modification du mot de passe du login SQL sur le serveur
                management.RemoveUser(databaseServerUser.SqlLogin);
            }
            catch (Exception ex)
            {
                LogManager.GetLogger().Error(ex);
                throw new DatabaseException(String.Format("Erreur dans la suppression du compte utilisateur {0} sur le serveur '{1}', Erreur: {2}", userLogin, serverName, ex.Message));
            }

            return(databaseServerUser);
        }
        public ActionResult <DatabaseServerUser> GetAccounts(int serverId, string userLogin)
        {
            DatabaseServerUser databaseServerUser = _service.GetAccountByServerLogin(serverId, userLogin);

            if (databaseServerUser == null)
            {
                return(NotFound());
            }

            return(Ok(databaseServerUser));
        }
        public List <ServerAccounUsertModel> GetAccountsByUserLogin(string userLogin)
        {
            List <ServerAccounUsertModel> list = new List <ServerAccounUsertModel>();

            // Liste des serveurs
            var servers = db.DatabaseServerName.ToList();
            // Liste des comptes de l'utilisateur
            //var accounts = db.DatabaseServerUser.Include(su => su.Server).Where(su => su.UserLogin.Equals(userLogin, StringComparison.InvariantCultureIgnoreCase)).ToList();
            var databaseServerUsers = db.DatabaseServerUser.AsEnumerable();
            var accounts            = databaseServerUsers.Where(su => su.UserLogin.Equals(userLogin, StringComparison.InvariantCultureIgnoreCase)).ToList();

            // parcours des serveurs
            foreach (DatabaseServerName serverName in servers)
            {
                ServerAccounUsertModel accounUsertModel = new ServerAccounUsertModel()
                {
                    Server    = serverName,
                    SqlLogin  = null,
                    UserLogin = null
                };

                // Le compte existe-t-il ?
                if (accounts.Count > 0)
                {
                    DatabaseServerUser account = accounts.Find(ac => ac.ServerId == serverName.Id);
                    if (account != null)
                    {
                        accounUsertModel.SqlLogin  = account.SqlLogin;
                        accounUsertModel.UserLogin = account.UserLogin;
                    }
                }

                list.Add(accounUsertModel);
            }

            return(list);

            /*var list = from dsn in db.DatabaseServerName
             *         join dsu in db.DatabaseServerUser on dsn.Id equals dsu.ServerId into dsuLeft
             *         from subdsu in dsuLeft.DefaultIfEmpty()
             *         where subdsu.UserLogin.Equals(userLogin, StringComparison.InvariantCultureIgnoreCase) || subdsu.UserLogin == null
             *         select new ServerAccounUsertModel
             *         {
             *             DatabaseServerName = dsn,
             *             SqlLogin = subdsu.SqlLogin,
             *             UserLogin = subdsu.UserLogin,
             *         };
             *
             * return list.ToList();*/
        }
        public void TestAddAccount()
        {
            DateTime           dateDuJour    = DateTime.Now;
            string             login         = string.Format("Test-{0}{1}{2}.{3}{4}", dateDuJour.Year, dateDuJour.Month, dateDuJour.Day, dateDuJour.Second, dateDuJour.Millisecond);
            ServerAccountModel serverAccount = new ServerAccountModel()
            {
                ServerId  = 0,
                UserLogin = login,
                Password  = "******"
            };

            DatabaseServerUser databaseServerUser = service.AddAccount(serverAccount);

            Assert.IsNotNull(databaseServerUser);
            Assert.IsFalse(string.IsNullOrWhiteSpace(databaseServerUser.SqlLogin));
        }
        public DatabaseServerUser AddAccount(ServerAccountModel serverAccount)
        {
            DatabaseServerUser databaseServerUser = new DatabaseServerUser
            {
                ServerId  = serverAccount.ServerId,
                UserLogin = serverAccount.UserLogin
            };

            string serverName = "Serveur non trouvé";

            try
            {
                // Obtention du serveur
                DatabaseServerName databaseServerName = this.db.DatabaseServerName.Find(serverAccount.ServerId);
                if (databaseServerName == null)
                {
                    return(null);
                }
                serverName = databaseServerName.Name;

                // Obtention du serveur réel : MySQL, SQL Server, ... avec son adresse IP
                DatabaseManagement management = DatabaseManagement.CreateDatabaseManagement(databaseServerName.Code, databaseServerName.Iplocale, databaseServerName.PortLocal);
                // Création du login SQL
                databaseServerUser.SqlLogin = management.MakeSqlLogin(serverAccount.UserLogin);
                // Ajout du login SQL sur le serveur
                management.AddOrUpdateUser(databaseServerUser.SqlLogin, serverAccount.Password);
            }
            catch (Exception ex)
            {
                LogManager.GetLogger().Error(ex);
                throw new DatabaseException(string.Format("Erreur dans l'ajout du compte utilisateur {0} sur le serveur '{1}', Erreur: {2}", serverAccount.ToString(), serverName, ex.Message));
            }

            // Ajout de l'utilisateur pour cette BD
            try
            {
                db.DatabaseServerUser.Add(databaseServerUser);
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException ex)
            {
                LogManager.GetLogger().Error(ex);
                throw new DatabaseException(string.Format("Erreur dans l'ajout du compte utilisateur {0} dans le référentiel", serverAccount.ToString()), ex);
            }

            return(databaseServerUser);
        }
        public static void InitialisationTests(TestContext context)
        {
            service = new ServerAccountService();

            // Ajout d'un compte pour les tests
            // Cela constitue aussi un test !
            ServerAccountModel serverAccount = new ServerAccountModel()
            {
                ServerId  = 0,
                UserLogin = "******",
                Password  = "******"
            };

            DatabaseServerUser databaseServerUser = service.AddAccount(serverAccount);

            Assert.IsNotNull(databaseServerUser);
        }
        public bool UpdateAccount(ServerAccountModel serverAccount)
        {
            DatabaseServerUser databaseServerUser = null;
            DatabaseServerName databaseServerName = null;
            string             serverName         = "Serveur non trouvé";

            try
            {
                // Obtention du serveur
                databaseServerName = this.db.DatabaseServerName.Find(serverAccount.ServerId);
                if (databaseServerName == null)
                {
                    return(false);
                }
                serverName = databaseServerName.Name;

                // Obtention du login SQL de l'utilisateur
                var databaseServerUsers = db.DatabaseServerUser.Include(su => su.Server).AsEnumerable();
                databaseServerUser = databaseServerUsers.SingleOrDefault(su => su.ServerId == serverAccount.ServerId && su.UserLogin.Equals(serverAccount.UserLogin, StringComparison.InvariantCultureIgnoreCase));
                if (databaseServerUser == null)
                {
                    return(false);
                }
            }
            catch (Exception ex)
            {
                LogManager.GetLogger().Error(ex);
                throw new DatabaseException(String.Format("Erreur dans l'obtention du compte utilisateur {0} dans le référentiel, Erreur: {1}", serverAccount.ToString(), ex.Message));
            }

            try
            {
                // Obtention du serveur réel : MySQL, SQL Server, ... avec son adresse IP
                DatabaseManagement management = DatabaseManagement.CreateDatabaseManagement(databaseServerName.Code, databaseServerName.Iplocale, databaseServerName.PortLocal);
                // Modification du mot de passe du login SQL sur le serveur
                management.AddOrUpdateUser(databaseServerUser.SqlLogin, serverAccount.Password);
            }
            catch (Exception ex)
            {
                LogManager.GetLogger().Error(ex);
                throw new DatabaseException(String.Format("Erreur dans la modification du compte utilisateur {0} sur le serveur '{1}', Erreur: {2}", serverAccount.ToString(), serverName, ex.Message));
            }

            return(true);
        }
        public ActionResult <DatabaseServerUser> PostAccounts(ServerAccountModel serverAccount)
        {
            // Vérification de l'appelant
            if (!this.SecurityCheckRoleAdminOrOwner(serverAccount.UserLogin))
            {
                return(Forbid());
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            DatabaseServerUser databaseServerUser = _service.AddAccount(serverAccount);

            if (databaseServerUser == null)
            {
                return(Conflict());
            }

            return(Ok(databaseServerUser));
            //return CreatedAtAction(nameof(GetAccountsByServerId ), new { id = databaseServerUser.ServerId }, databaseServerUser);
        }
Beispiel #11
0
        public IHttpActionResult PostAccounts(ServerAccountModel serverAccount)
        {
            // Vérification de l'appelant
            IHttpActionResult result = this.SecurityCheckRoleAdminOrOwner(serverAccount.UserLogin);

            if (result != null)
            {
                return(result);
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            DatabaseServerUser databaseServerUser = service.AddAccount(serverAccount);

            if (databaseServerUser == null)
            {
                return(Conflict());
            }

            return(CreatedAtRoute("DefaultApi", new { id = databaseServerUser.ServerId }, databaseServerUser));
        }
Beispiel #12
0
        public DatabaseDB AddDatabase(DatabaseModel database)
        {
            // Vérification du nom
            if (!RegularExpression.IsCorrectFileName(database.NomBD))
            {
                throw new DatabaseException("Le nom ne doit pas comporter des caractères spéciaux.");
            }

            // Le nom de la base de données doit être unique sur un serveur donné
            if (GetDatabase(database.ServerId, database.NomBD) != null)
            {
                throw new DatabaseException("Le nom de la base de données existe déjà.");
            }

            string             serverName         = "Serveur non trouvé";
            DatabaseServerUser databaseServerUser = null;

            try
            {
                // Obtention du serveur
                DatabaseServerName databaseServerName = this.db.DatabaseServerNames.Find(database.ServerId);
                if (databaseServerName == null)
                {
                    return(null);
                }

                // Obtention du compte utilisateur du serveur
                ServerAccountService serverAccountService = new ServerAccountService(this.ServiceEpsiContext);
                databaseServerUser = serverAccountService.GetAccountByServerLogin(database.ServerId, database.UserLogin);
                if (databaseServerUser == null)
                {
                    return(null);
                }

                // Obtention du serveur réel : MySQL, SQL Server, ... avec son adresse IP
                DatabaseManagement management = DatabaseManagement.CreateDatabaseManagement(databaseServerName.Code, databaseServerName.IPLocale, databaseServerName.PortLocal);
                if (management == null)
                {
                    return(null);
                }

                // et céation de la base de données sur le serveur de BD
                management.CreateDatabase(database.NomBD, databaseServerUser.SqlLogin);
            }
            catch (Exception ex)
            {
                LogManager.GetLogger().Error(ex);
                throw new DatabaseException(string.Format("Erreur dans l'ajout de la base de données {0} sur le serveur '{1}'", database.ToString(), serverName), ex);
            }

            // Ajout de la base de données dans le référentiel
            DatabaseDB databaseDB = new DatabaseDB
            {
                ServerId     = database.ServerId,
                NomBD        = database.NomBD,
                DateCreation = DateTime.Now,
                Commentaire  = database.Commentaire
            };

            db.DatabaseDBs.Add(databaseDB);

            try
            {
                db.SaveChanges();

                // puis du créateur comme contributeur avec tous les droits
                DatabaseGroupUser databaseGroupUser = new DatabaseGroupUser
                {
                    DbId             = databaseDB.Id,
                    UserLogin        = databaseServerUser.UserLogin,
                    UserFullName     = database.UserFullName,
                    SqlLogin         = databaseServerUser.SqlLogin,
                    GroupType        = DatabaseValues.ADMINISTRATEUR,
                    AddedByUserLogin = databaseServerUser.UserLogin
                };
                db.DatabaseGroupUsers.Add(databaseGroupUser);
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException ex)
            {
                if (!Exists(databaseDB.ServerId))
                {
                    return(null);
                }
                else
                {
                    LogManager.GetLogger().Error(ex);
                    throw new DatabaseException(string.Format("Erreur dans l'ajout de la base de données dans le référentiel", database.ToString()), ex);
                }
            }

            // Enregistrement dans les logs
            WriteLogs("BDD Création - " + string.Format("L'utilisateur '<b>{0}</b>' a créé la bdd '{1}' de type '{2}'", database.UserLogin, database.NomBD, database.ServerId));
            return(databaseDB);
        }
        public void TestRemoveAccount()
        {
            DatabaseServerUser databaseServerUser = service.RemoveAccount(0, "UnitTest");

            Assert.IsNotNull(databaseServerUser);
        }