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);
}
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));
}
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);
}