/// <summary>
/// Actualiza un Servidor.
/// </summary>
/// <param name="server">Servidor a actualizar</param>
/// <returns></returns>
public int update(ServerDTO server)
{
int generatedKey = -1;
try {
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "UPDATE server SET nombre = ?name, popurl = ?popserver, smtpurl = ?smtpserver, popport = ?popport, smtpport = ?smtpport, isssl = ?ssl WHERE " +
"idserver = ?idserver";
myCommand.Parameters.Add("?name", MySqlDbType.VarChar).Value = server.Name;
myCommand.Parameters.Add("?popserver", MySqlDbType.VarChar).Value = server.PopServer;
myCommand.Parameters.Add("?smtpserver", MySqlDbType.VarChar).Value = server.SmtpServer;
myCommand.Parameters.Add("?popport", MySqlDbType.VarChar).Value = server.PopPort;
myCommand.Parameters.Add("?smtpport", MySqlDbType.VarChar).Value = server.SmtpPort;
myCommand.Parameters.Add("?ssl", MySqlDbType.VarChar).Value = server.Ssl;
myCommand.Parameters.Add("?idserver", MySqlDbType.VarChar).Value = server.Id;
//Puede ser que sea algo tipo generatedKey = myCommand.ExecuteNonQuery();
generatedKey = myCommand.ExecuteNonQuery();
}
catch (Exception ex) { }
return(generatedKey);
}
public void Dispose()
{
_serverDTO = null;
_arrDriveInfo = null;
_arrProcesses = null;
GC.Collect();
}
private void MergeDriveInfo(ref ServerDTO serverDTO, DriveInfo[] arrDriveInfo)
{
if (arrDriveInfo != null)
{
serverDTO.Drives = new List <DriveDTO>();
DriveDTO drv = null;
foreach (DriveInfo di in arrDriveInfo)
{
drv = new DriveDTO();
drv.DriveName = di.Name;
drv.IsReady = di.IsReady;
if (drv.IsReady)
{
drv.DriveID = di.VolumeLabel;
drv.DriveCapacity = di.TotalSize;
drv.DriveFreeSpace = di.TotalFreeSpace;
drv.ConsumedSpace = di.TotalSize - di.TotalFreeSpace;
}
else
{
drv.DriveMessage = "Device is not ready";
}
serverDTO.Drives.Add(drv);
}
drv = null;
}
arrDriveInfo = null;
}
/// <summary>
/// Método encargado de obtener las propiedades necesarias para realizar
/// la conexión con el tipo de Servidor necesario.
/// </summary>
/// <param name="envio">Se configura para enviar si es TRUE, para recibir si es FALSE</param>
/// <param name="server">Servidor del cual se quiere obtener la configuración</param>
/// <returns></returns>
public Property obtenerPropiedades(bool envio, ServerDTO server)
{
Property propiedad = new Property();
try
{
IServerProperty propiedadObtenida;
switch (server.Name)
{
case "GMAIL":
propiedadObtenida = new Gmail();
if (envio)
{
propiedad = propiedadObtenida.getPropiedadEnviar(server);
}
else
{
propiedad = propiedadObtenida.getPropiedadRecibir(server);
}
break;
case "OUTLOOK":
///
break;
case "YAHOO":
///
break;
}
}
catch (Exception ex) { }
return(propiedad);
}
public async Task <ServerDTO> UpdateServerAsync(ServerDTO serverDto)
{
var server = _mapper.Map <Server>(serverDto);
var result = await _repository.UpdateAsync(server);
return(_mapper.Map <ServerDTO>(result));
}
/// <summary>
/// Agrega un nuevo servidor a la Base de Datos.
/// </summary>
/// <param name="server">Servidor a agregar</param>
/// <returns>True si se agregó con éxito - False si ocurrió un error al ejecutar la consulta</returns>
public int save(ServerDTO server)
{
int generatedKey;
try
{
connection.Open();
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "INSERT INTO server (nombre,popurl,smtpurl,popport,smtpport,isssl ) VALUES " +
"(?name, ?popserver, ?smtpserver, ?popport, ?smtpport, ?ssl) ";
myCommand.Parameters.Add("?name", MySqlDbType.VarChar).Value = server.Name;
myCommand.Parameters.Add("?popserver", MySqlDbType.VarChar).Value = server.PopServer;
myCommand.Parameters.Add("?smtpserver", MySqlDbType.VarChar).Value = server.SmtpServer;
myCommand.Parameters.Add("?popport", MySqlDbType.VarChar).Value = server.PopPort;
myCommand.Parameters.Add("?smtpport", MySqlDbType.VarChar).Value = server.SmtpPort;
myCommand.Parameters.Add("?ssl", MySqlDbType.Int16).Value = server.Ssl;
generatedKey = myCommand.ExecuteNonQuery();
connection.Close();
}
catch (Exception)
{
throw;
}
return(generatedKey);
}
public IHttpActionResult StopProcess([FromBody] ReqProcessDTO process)
{
Utilities.ServerTracker srvTrck = Utilities.ServerTracker.GetInstance;
ServerDTO srvr = srvTrck.CurrentServerLists.FirstOrDefault(srv => srv.ServerIP == process.ServerIP);
bool status = true;
string message = string.Empty;
if (srvr != null)
{
int intProcId = Int32.Parse(process.ProcessId);
BasicHttpBinding wcfBinding = new BasicHttpBinding();
EndpointAddress wcfEndPoint = new EndpointAddress(srvr.WCFHostingURL);
ChannelFactory <GSM.Common.Contracts.IRemoteProcSvc> cfToCallWcf = new ChannelFactory <GSM.Common.Contracts.IRemoteProcSvc>(wcfBinding, wcfEndPoint);
GSM.Common.Contracts.IRemoteProcSvc instance = cfToCallWcf.CreateChannel();
// Call Service.
status = instance.EndProcess(intProcId);
//string message = string.Empty;
if (!status)
{
message = "Failed to stop process.";
}
cfToCallWcf.Close();
}
return(Ok(new { Status = status, Message = message }));
}
public void PopulateChildren()
{
this.Children.Clear();
if (ServerDTO.CanLogin())
{
AddChildren();
}
}
public JsonResult ReleaseServer(ServerDTO serverDTO)
{
_service.ReleaseServer(serverDTO.Name);
return(new JsonResult {
Data = new { Status = "Success", ReleasedBy = serverDTO?.User?.Name }
});
}
/// <summary>
/// Método para obtener todos los datos existentes de un servidor
/// </summary>
/// <param name="server"></param>
/// <returns></returns>
public ServerDTO ObtenerServer(ServerDTO server)
{
factory.startConnection();
ServerDTO serverObtenido = factory.getServer().get(server);
factory.closeConnection();
return(serverObtenido);
}
public JsonResult BlockServer(ServerDTO serverDTO)
{
_service.BlockServer(serverDTO.Name, serverDTO?.User?.Name);
return(new JsonResult {
Data = new { Status = "Success", BlockedBy = serverDTO?.User?.Name }
});
}
public void ConectarSmtp(ServerDTO server, CuentaDTO cuenta)
{
cliente = new SmtpClient();
cliente.Host = server.SmtpServer;
cliente.Port = server.SmtpPort;
cliente.DeliveryMethod = SmtpDeliveryMethod.Network;
cliente.EnableSsl = server.Ssl;
cliente.Credentials = new NetworkCredential(cuenta.User, cuenta.Password);
}
public IActionResult ServerDetailedInfo([FromBody] ServerDTO serverDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var server = new Server(serverDto.IpAddress, serverDto.Port);
return(Ok(server));
}
public async Task <IActionResult> Post(ServerDTO serverDTO)
{
Server server = new Server
{
ServerId = serverDTO.ServerId,
ServerURL = serverDTO.ServerURL
};
await DataBaseCalls.AddServer(_context, server);
return(Created("", null));
}
public void ConectarPop(ServerDTO server, CuentaDTO cuenta)
{
cliente = new Pop3Client();
try {
cliente.Connect(server.PopServer, server.PopPort, server.Ssl);
cliente.Authenticate(cuenta.User, cuenta.Password);
}
catch (OpenPop.Pop3.Exceptions.PopClientException ex) {
Console.WriteLine(ex.Message);
}
}
public void enviarCorreo(CorreoDTO correo)
{
try
{
CuentaDTO cuenta = Cuenta.getInstance().ObtenerCuentaDeCorreo(correo);
ServerDTO server = new ServerDTO();
server.Id = cuenta.Server;
server = Server.getInstance().ObtenerServer(server);
//Sesión
MailMessage mensaje = new MailMessage();
//Agrego destinatarios, guardados en la lista de OrigenDestino
foreach (OrigenDestinoDTO od in correo.OrigenDestino)
{
//Si es CC
if (od.Cc == true)
{
mensaje.CC.Add(new MailAddress(od.Direccion));
}
//Si es CCO
else if (od.Cco == true)
{
mensaje.Bcc.Add(new MailAddress(od.Direccion));
}
//Sino, es Para
else
{
mensaje.To.Add(new MailAddress(od.Direccion));
}
}
mensaje.Subject = correo.Asunto;
mensaje.Body = correo.Detalle;
//Adjuntos
//foreach (AttachmentDTO adjunto in correo.Adjuntos) {
//}
mensaje.From = new MailAddress(cuenta.User);
AdminSmtp smtp = new AdminSmtp();
smtp.ConectarSmtp(server, cuenta);
//If enviado < 0 -> error al enviar
int enviado = smtp.Enviar(mensaje, false);
}
catch (Exception ex) { }
}
public void DoLogout()
{
MMCActionHelper.CheckedExec(delegate
{
if (ServerDTO.IsLoggedIn)
{
ServerDTO.Cleanup();
this.Children.Clear();
this.ActionsPaneItems.Clear();
this.ActionsPaneItems.Add(new Microsoft.ManagementConsole.Action("Login",
"Login", -1, ACTION_LOGIN));
}
});
}
private void dgvServidores_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
if (dgvServidores.Rows.Count == 0)
{
return;
}
DataGridViewRow fila = dgvServidores.SelectedRows[0];
int idservidor = int.Parse(fila.Cells[0].Value.ToString());
ServerDTO serverSeleccionado = new ServerDTO();
serverSeleccionado.Id = idservidor;
server = Controller.Server.getInstance().ObtenerServer(serverSeleccionado);
CargarCampos();
}
public async Task <ActionResult> AddAsync([FromBody] ServerDTO server)
{
try
{
if (server == null)
{
return(BadRequest($"Error when try to add a new server"));
}
var result = await _service.AddServerAsync(server);
return(new ObjectResult(result));
}
catch (Exception ex)
{
return(BadRequest($"Error when try to add a new server: {ex.Message}"));
}
}
public Property getPropiedadEnviar(ServerDTO server)
{
try
{
Property propiedad = new Property();
propiedad.set("mail.smtp.host", server.SmtpServer);
propiedad.set("mail.smtp.port", server.SmtpPort);
propiedad.set("mail.smtp.ssl.socketFactory.fallback", "false");
propiedad.set("mail.smtp.starttls.enable", "false");
propiedad.set("mail.smtp.ssl.enable", "true");
propiedad.set("mail.smtp.ssl.checkserveridentity ", " true ");
return(propiedad);
}
catch (Exception ex) {
return(null);
}
}
public async Task DoLogin()
{
try
{
if (!ServerDTO.IsLoggedIn)
{
var frmLogin = new LoginForm(ServerDTO.Server, ServerDTO.UserName, ServerDTO.DomainName);
if (MMCDlgHelper.ShowForm(frmLogin))
{
ServerDTO.Server = frmLogin.Server;
ServerDTO.UserName = frmLogin.UserName;
ServerDTO.Password = frmLogin.Password;
ServerDTO.DomainName = frmLogin.DomainName;
await ServerDTO.LogintoServer(frmLogin.UserName, frmLogin.Password, frmLogin.DomainName);
if (ServerDTO.IsLoggedIn)
{
PopulateChildren();
this.DisplayName = ServerDTO.Server;
this.ActionsPaneItems.Clear();
this.ActionsPaneItems.Add(new Microsoft.ManagementConsole.Action("Logout",
"Logout", -1, ACTION_LOGOUT));
this.ActionsPaneItems.Add(new Microsoft.ManagementConsole.Action("Get Server version",
"Get Server version", -1, ACTION_GET_SERVER_VERSION));
this.ActionsPaneItems.Add(new Microsoft.ManagementConsole.Action("Show root certificate",
"Show VMCA Root certificate", -1, ACTION_SHOW_ROOT_CERTIFICATE));
this.ActionsPaneItems.Add(new Microsoft.ManagementConsole.Action("Add root certificate",
"Add Root certificate", -1, ACTION_ADD_ROOT_CERTIFICATE));
this.ViewDescriptions[0].DisplayName = "Logged in as: " + ServerDTO.UserName + "@" + ServerDTO.DomainName;
}
else
{
throw new Exception(CommonConstants.UNABLE_TO_LOGIN);
}
}
}
}
catch (Exception e)
{
MMCDlgHelper.ShowException(e);
}
}
public IHttpActionResult SendDetail(ServerDTO serverDTO)
{
Utilities.ServerTracker srvTrck = Utilities.ServerTracker.GetInstance;
ServerDTO srvr = srvTrck.CurrentServerLists.FirstOrDefault(srv => srv.ServerIP == serverDTO.ServerIP);
if (srvr == null)
{
srvTrck.CurrentServerLists.Add(serverDTO);
}
else
{
srvr = serverDTO;
}
Hubs.NotificationHub hub = new Hubs.NotificationHub();
hub.SendDetails(serverDTO);
serverDTO = null;
hub = null;
GC.Collect();
return(Ok(new { Status = true, Message = "" }));
}
/// <summary>
/// Elimina un Servidor de la Base de Datos.
/// </summary>
/// <param name="server">Servidor a eliminar</param>
/// <returns></returns>
public int delete(ServerDTO server)
{
int generatedKey = -1;
try
{
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "DELETE FROM server WHERE idserver = ?idserver";
myCommand.Parameters.Add("?idserver", MySqlDbType.VarChar).Value = server.Id;
//Puede ser que sea algo tipo generatedKey = myCommand.ExecuteNonQuery();
generatedKey = myCommand.ExecuteNonQuery();
}
catch (Exception ex) { }
return(generatedKey);
}
private void MergeProcessInfo(ref ServerDTO serverDTO, Process[] arrProcessInfo)
{
if (arrProcessInfo != null)
{
serverDTO.Processes = new List <ProcessDTO>();
ProcessDTO prcss = null;
foreach (Process proc in arrProcessInfo)
{
prcss = new ProcessDTO();
prcss.Id = proc.Id;
prcss.ProcessName = proc.ProcessName;
prcss.MachineName = proc.MachineName;
prcss.WorkingSet64 = proc.WorkingSet64;
prcss.PeakWorkingSet64 = proc.PeakWorkingSet64;
serverDTO.Processes.Add(prcss);
}
prcss = null;
}
arrProcessInfo = null;
}
private void ActualizarDatosLista(List <CuentaDTO> cuentas)
{
if (dgvCuentas.Rows.Count != 0)
{
foreach (DataGridViewRow fila in dgvCuentas.Rows)
{
dgvCuentas.Rows.Remove(fila);
}
}
foreach (CuentaDTO cuenta in cuentas)
{
ServerDTO servidortemp = new ServerDTO();
servidortemp.Id = cuenta.Server;
ServerDTO servidor = Controller.Server.getInstance().ObtenerServer(servidortemp);
dgvCuentas.Rows.Add(cuenta.IdCuenta.ToString(), cuenta.User, servidor.Name);
}
}
private void CargarCampos()
{
if (cuenta == null)
{
return;
}
txtUsuario.Text = cuenta.User;
txtPassword.Text = cuenta.Password;
ServerDTO servidortemp = new ServerDTO();
servidortemp.Id = cuenta.Server;
ServerDTO servidor = Controller.Server.getInstance().ObtenerServer(servidortemp);
try
{
comboServidor.SelectedItem = servidor.Name;
}
catch (Exception ex) { }
}
/// <summary>
/// Obtiene un servidor almacenado en la Base de Datos.
/// </summary>
/// <param name="server">Servidor a obtener</param>
/// <returns>Servidor encontrado</returns>
public ServerDTO get(ServerDTO server)
{
ServerDTO serverObtenido = new ServerDTO();
try
{
connection.Open();
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "SELECT idserver,nombre,popurl,popport,smtpurl,smtpport,isssl FROM server WHERE " +
"idserver = ?idserver";
myCommand.Parameters.Add("?idserver", MySqlDbType.VarChar).Value = server.Id;
MySqlDataReader myReader = myCommand.ExecuteReader();
while (myReader.Read())
{
serverObtenido.Id = myReader.GetInt32(0);
serverObtenido.Name = myReader.GetString(1);
serverObtenido.PopServer = myReader.GetString(2);
serverObtenido.PopPort = myReader.GetInt32(3);
serverObtenido.SmtpServer = myReader.GetString(4);
serverObtenido.SmtpPort = myReader.GetInt32(5);
serverObtenido.Ssl = myReader.GetBoolean(6);
}
myReader.Close();
connection.Close();
}
catch (MySqlException ex) { }
return(serverObtenido);
}
/// <summary>
/// Lista todos los servidores existentes en la Base de Datos.
/// </summary>
/// <returns>Lista de ServerDTO</returns>
public List <ServerDTO> list()
{
ServerDTO serverObtenido;
List <ServerDTO> list = new List <ServerDTO>();
try {
connection.Open();
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "SELECT idserver,nombre,popurl,popport,smtpurl,smtpport,isssl FROM server";
MySqlDataReader myReader = myCommand.ExecuteReader();
while (myReader.Read())
{
serverObtenido = new ServerDTO();
serverObtenido.Id = myReader.GetInt32(0);
serverObtenido.Name = myReader.GetString(1);
serverObtenido.PopServer = myReader.GetString(2);
serverObtenido.PopPort = myReader.GetInt32(3);
serverObtenido.SmtpServer = myReader.GetString(4);
serverObtenido.SmtpPort = myReader.GetInt32(5);
serverObtenido.Ssl = myReader.GetBoolean(6);
list.Add(serverObtenido);
}
myReader.Close();
connection.Close();
}
catch (MySqlException ex) { }
return(list);
}
private void RunMonitor()
{
ServerDTO serverDTO = null;
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(System.Configuration.ConfigurationManager.AppSettings["BASE_ADDRESS_API"]);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
IServerSvc _iSvc = null;
string wcfHostAddress = System.Configuration.ConfigurationManager.AppSettings["BASE_ADDR_WCF"];
while (true)
{
System.Threading.Thread.Sleep(1000);
using (_iSvc = new ServerSvc())
{
serverDTO = _iSvc.GetServerInformation();
serverDTO.WCFHostingURL = wcfHostAddress;
if (!string.IsNullOrEmpty(serverDTO.ServerIP) && !string.IsNullOrEmpty(serverDTO.ServerName))
{
var response = client.PostAsJsonAsync("api/server/sendDetail", serverDTO).Result;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Call status successful...");
}
else
{
Console.WriteLine("Call status error...");
}
}
else
{
Console.WriteLine("Server IP or Server Name is not found");
}
}
}
}
/// <summary>
/// Método para eliminar un servidor
/// </summary>
/// <param name="server">Cuenta que se va a eliminar</param>
public void EliminarCuenta(ServerDTO server)
{
factory.startConnection();
factory.getServer().delete(server);
factory.closeConnection();
}
