/// <summary>
/// Obtiene la configuración desde el archivo XML.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 08/10/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="claseDAO">Tipo de la clase de un DAO.</param>
/// <returns></returns>
public static DynamicQueryRoot ObtenerConfiguracion(Type claseDAO)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
string DynamicQueryConfigPath = FrameworkConfigurationManager.ObtenerRutaArchivoConfiguracion(CARPETA_DYNAMIC_QUERIES);
string ruta = monitor.ObtenerRutaArchivo(DynamicQueryConfigPath, claseDAO.FullName + ".dbq.xml");
string clave = null;
if (monitor.Existe(ruta))
{
DynamicQueryConfigPath = ruta;
clave = claseDAO.FullName;
}
else
{
DynamicQueryConfigPath = monitor.ObtenerRutaArchivoExistente(DynamicQueryConfigPath, claseDAO.Name + ".dbq.xml");
clave = claseDAO.Name;
}
if ((!ArchivosConsultas.ContainsKey(clave)) || (monitor.FueModificado(ArchivosConsultas[clave].FechaUltimaModificacion, DynamicQueryConfigPath)))
{
XmlSerializer serializer = new XmlSerializer(typeof(DynamicQueryRoot));
FileStream file = null;
DynamicQueryRoot retorno = null;
try
{
file = new FileStream(DynamicQueryConfigPath, FileMode.Open);
retorno = serializer.Deserialize(file) as DynamicQueryRoot;
}
catch (Exception e)
{
throw e;
}
finally
{
if (file != null)
{
file.Close();
}
}
if (retorno != null)
{
Configuracion = retorno;
}
if (!ArchivosConsultas.ContainsKey(clave))
{
ArchivosConsultas.Add(clave, retorno);
}
ArchivosConsultas[clave].FechaUltimaModificacion = monitor.ObtenerFechaUltimaModificacion(DynamicQueryConfigPath);
}
return(Configuracion);
}
static int Main(string[] args)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
string rutaLogError = monitor.ObtenerRutaAbsoluta(".[DS]Error.log.txt");
try
{
FileSystemManager manager = new FileSystemManager();
AdministradorArchivoTag admin = manager.ObtenerConfiguracion();
foreach (Accion accion in admin.Acciones)
{
foreach (FileSystem fileSystem in FileSystemManager.ObtenerFileSystems(accion))
{
IList <Evaluador <object> > evaluadores = FileSystemManager.ObtenerEvaluadores(admin.Evaluadores);
IList <ExpresionCondicional> condiciones = FileSystemManager.ObtenerCondiciones(accion.Condiciones);
if (EvaluadorExpresiones.EvaluarCondiciones(fileSystem, condiciones, evaluadores))
{
accion.Realizar(fileSystem);
}
}
}
if (monitor.Existe(rutaLogError))
{
new Eliminar().Realizar(new FileSystem()
{
Info = new FileInfo(rutaLogError), Tipo = TipoFileSystem.Archivo
});
}
}
catch (Exception ex)
{
FileStream logError = new FileStream(rutaLogError, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
StreamWriter writer = new StreamWriter(logError);
writer.AutoFlush = true;
Exception exepcionAux = ex;
while (exepcionAux != null)
{
writer.WriteLine(exepcionAux.Message);
writer.WriteLine("------------------------------------------------------------------------------");
writer.WriteLine(exepcionAux.StackTrace);
writer.WriteLine("\n");
exepcionAux = exepcionAux.InnerException;
}
writer.Close();
logError.Close();
return(1);
}
return(0);
}
public override void Inicializar()
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
if (NumeroArchivo == 0)
{
NumeroArchivo = 1;
}
if (Rolling.By.Equals("Date", StringComparison.InvariantCultureIgnoreCase))
{
if (Rolling.Unit.Equals("Day", StringComparison.InvariantCultureIgnoreCase))
{
checked
{
if (FechaUltimoArchivoCreado.AddDays((int)Rolling.Value) >= DateTime.Now)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
else if (Rolling.Unit.Equals("Week", StringComparison.InvariantCultureIgnoreCase))
{
checked
{
int diferenciaDias = (int)Rolling.Value;
diferenciaDias *= 7;
if (FechaUltimoArchivoCreado.AddDays(diferenciaDias) >= DateTime.Now)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
else if (Rolling.Unit.Equals("Month", StringComparison.InvariantCultureIgnoreCase))
{
checked
{
if (FechaUltimoArchivoCreado.AddMonths((int)Rolling.Value) >= DateTime.Now)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
else if (Rolling.Unit.Equals("Year", StringComparison.InvariantCultureIgnoreCase))
{
checked
{
if (FechaUltimoArchivoCreado.AddYears((int)Rolling.Value) >= DateTime.Now)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
}
else if (Rolling.By.Equals("Size", StringComparison.InvariantCultureIgnoreCase))
{
if (monitor.Existe(RutaActualArchivo))
{
//Tamaño en MB.
double tamañoArchivo = (new FileInfo(RutaActualArchivo).Length / 1048576.0);
double tamañoLimite = Rolling.Value;
if (Rolling.Unit.Equals("GB", StringComparison.InvariantCultureIgnoreCase))
{
tamañoLimite *= 1024;
}
if (Rolling.Unit.Equals("MB", StringComparison.InvariantCultureIgnoreCase) ||
Rolling.Unit.Equals("GB", StringComparison.InvariantCultureIgnoreCase))
{
if (tamañoArchivo > tamañoLimite)
{
FechaUltimoArchivoCreado = DateTime.Now;
NumeroArchivo++;
}
}
}
}
string ruta = Output.ObtenerRuta(NumeroArchivo);
if (RutaActualArchivo != ruta)
{
file = new FileStream(ruta, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
writer = new StreamWriter(file)
{
AutoFlush = true
};
}
RutaActualArchivo = ruta;
}
/// <summary>
/// Carga la configuración desde el archivo XML a memoria. De paso lo valida.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <exception cref="Ada.Framework.Util.FileMonitor.Exceptions.ArchivoNoEncontradoException">Lanzado al no encontrar el archivo XML o su esquema.</exception>
/// <exception cref="Ada.Framework.Data.DBConnector.Connections.Exceptions.ConfiguracionBaseDatosException">Lanzado al encontrar al archivo de configuración inválido.</exception>
public void CargarConfiguracion(bool comprobarFechaModificacion = false)
{
IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
if (monitor.Existe(DataBaseConnectionsPath))
{
if (!fechaUltimaModificacionArchivo.HasValue)
{
fechaUltimaModificacionArchivo = new DateTime(1, 1, 1);
}
if (!comprobarFechaModificacion || (Conexiones == null || Conexiones.Count == 0 || monitor.FueModificado(fechaUltimaModificacionArchivo.Value, DataBaseConnectionsPath)))
{
Conexiones = new List <ConexionTO>();
Conectores = new List <ConectorTO>();
XmlDocument doc;
XmlReader reader = null;
try
{
CargarXML(out doc, out reader);
foreach (XmlNode appender in doc.DocumentElement.ChildNodes[1].ChildNodes)
{
if (appender is XmlElement)
{
XmlElement element = (appender as XmlElement);
Conectores.Add(new ConectorTO()
{
Name = element.GetAttribute("Name"),
Instance = element.GetAttribute("Instance"),
AssemblyName = element.GetAttribute("AssemblyName"),
AssemblyPath = element.GetAttribute("AssemblyPath")
});
}
}
foreach (XmlNode elemento in doc.DocumentElement.ChildNodes[0].ChildNodes)
{
if (elemento is XmlElement)
{
XmlElement element = (elemento as XmlElement);
ConectorTO conector = Conectores.Where(c => c.Name == element.GetAttribute("Type")).First();
Conexiones.Add(new ConexionTO()
{
ConnectionString = element.GetAttribute("ConnectionString"),
Name = element.GetAttribute("Name"),
Instance = conector.Instance,
Type = element.GetAttribute("Type"),
AssemblyName = conector.AssemblyName,
AssemblyPath = conector.AssemblyPath
});
}
}
}
finally
{
if (reader != null)
{
reader.Close();
}
}
}
fechaUltimaModificacionArchivo = monitor.ObtenerFechaUltimaModificacion(DataBaseConnectionsPath);
}
else
{
throw new ArchivoNoEncontradoException("¡No se ha encontrado el archivo de conexiones a bases de datos!", DataBaseConnectionsPath);
}
}