internal BasicTextLogger(string FilePath, TipoLog tipoLog)
{
if(!string.IsNullOrEmpty(FilePath))
{
TipoDeLog = tipoLog;
LogPath = FilePath;
}
}
public static void Log(TipoLog tipo, string msg) {
switch (tipo) {
case TipoLog.ARTE : if(!mostrarArte) return; break;
case TipoLog.AI : if(!mostrarAI) return; break;
case TipoLog.SOM : if(!mostrarSom) return; break;
case TipoLog.GAMEPLAY : if(!mostrarGameplay) return; break;
}
Debug.Log (tipo.ToString () + ": " + msg);
}
public void RegistrarLog(string mensagem, TipoLog tipoLog)
{
switch (tipoLog)
{
//case TipoLog.Erro: (new LOG4NET()).Write(mensagem, "Erro");
//case TipoLog.Warning: (new LOG4NET()).Write(mensagem, "Aviso");
//default: throw new Exception("Tipo de erro não exite");
}
}
public static void Escribir(TipoLog tipo, string Descripcion)
{
string nombreArchivo = ConfigurationManager.AppSettings["DirectorioLogs"];
StreamWriter archivo;
nombreArchivo += tipo.ToString()+ ".log";
archivo = new StreamWriter(nombreArchivo, true);
archivo.WriteLine(DateTime.Now + " : " + Descripcion);
archivo.Close();
}
internal string ToString(TipoLog tipo)
{
try
{
switch(tipo)
{
case TipoLog.json:
{
return String.Format("{{'evento':'{0}','data':'{1}','mensagem':'{2}','outros':'{3}'}}", Tipo, Momento, Mensagem, Outros);
}
case TipoLog.texto:
{
return String.Format(@"
--> tipo: {0} ({1})
mensagem:
{2}
outros: {3}
------------------",
Tipo,
Momento,
Mensagem,
Outros);
}
case TipoLog.textoMinimo:
{
return String.Format(@"({1})
{2}
{3}
",
Tipo,
Momento,
Mensagem,
Outros);
}
case TipoLog.xmlfragment:
{
return String.Format(@"
<evento tipo=""{0}"" data=""{1}"">
<mensagem>{2}</mensagem>
<outros>{3}</outros>
</evento>",
TrataStringParaXml(Tipo.ToString()),
TrataStringParaXml(Momento.ToString()),
TrataStringParaXml(Mensagem.ToString()),
TrataStringParaXml(Outros.ToString()));
}
}
}
catch
{
Console.WriteLine("Poop");
}
return "";
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="tipoLog">O tipo de log a que o atributo pertence.</param>
/// <param name="campo">O nome do campo que aparecerá no Log. Pode ter até 30 caracteres.</param>
/// <param name="campoDescricaoModel">O nome da propriedade da Model que contém a descrição.</param>
/// <param name="tipoDAO">O tipo da DAO que contém a descrição.</param>
/// <param name="campoIdModel">O nome da propriedade da Model que contém o ID.</param>
/// <param name="nomeMetodoDAO">O nome do método que retorna o item da DAO.</param>
/// <param name="incluirValorPrimeiroParametro">O valor do item deve ser incluído como o primeiro parâmetro?</param>
/// <param name="parametrosMetodoDAO.Instance">Os parâmetros do método de retorno.</param>
public LogModelAttribute(TipoLog tipoLog, string campo, bool isCampoEFD, string campoDescricaoModel, Type tipoDAO, string campoIdModel,
string nomeMetodoDAO, bool incluirValorPrimeiroParametro, params object[] parametrosMetodoDAO)
{
Campo = campo;
TipoLog = tipoLog;
IsCampoEFD = isCampoEFD;
TipoDAO = tipoDAO;
NomeMetodoDAO = nomeMetodoDAO;
IncluirValorPrimeiroParametro = incluirValorPrimeiroParametro;
ParametrosMetodoDAO = parametrosMetodoDAO;
CampoIdModel = campoIdModel;
CampoDescricaoModel = campoDescricaoModel;
}
public ResultProcessing Salvar(string descricao, TipoLog tipo, string usuario = "", string ip = "", string statusAnterior = "", string statusAtual = "")
{
Log item = new Log()
{
Descricao = descricao,
TipoLog = tipo,
NomeUsuario = usuario,
Ip = ip,
StatusAnterior = statusAnterior,
StatusAtual = statusAtual
};
return(Salvar(item));
}
public async Task LogEcommerce(TipoLog tipoLog, object objeto)
{
string actionName = this.ControllerContext.RouteData.Values["action"].ToString();
string controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
await _iLogSistemaApp.Add(new LogSistema
{
TipoLog = tipoLog,
JsonInformacao = JsonConvert.SerializeObject(objeto),
UserId = await RetornarIdUsuarioLogado(),
NomeAction = actionName,
NomeController = controllerName
});
}
/// <summary>
/// Loga operação
/// </summary>
/// <param name="mensagem"></param>
/// <param name="tipoLog"></param>
public static void LogEvent(string mensagem, TipoLog tipoLog)
{
string dateLog = DateTime.Now.ToShortDateString().ToString() + " " + DateTime.Now.ToLongTimeString().ToString();
string fullLocation = GetCurrentFileLogName();
XDocument doc = XDocument.Load(fullLocation);
XElement root = new XElement("LOG");
root.Add(new XAttribute("tipo", tipoLog.ToString()));
root.Add(new XAttribute("mensagem", mensagem));
root.Add(new XAttribute("data", dateLog));
doc.Element("LOGS").Add(root);
doc.Save(fullLocation);
}
/// <summary>
/// Registra el Log de auditoría del sistema
/// </summary>
/// <param name="Empleado">Empleado activo en la aplicación</param>
/// <param name="Equipo">Equipo desde el cual ingreso a la aplicacion. Se obtiene de la variable Session["Host"]</param>
/// <param name="TLog">Tipo de Log. Se Obtiene de Componentes.BLL.SE.ESLog.TipoLog</param>
/// <param name="TTransaccion">Tipo de Transacción. Se obtiene de Componentes.BLL.SE.ESLog.TipoTransaccion</param>
/// <param name="Requerimiento">Requerimiento activo</param>
/// <param name="Modulo">Módulo al cual pertenece el requerimiento activo</param>
/// <param name="Referencia">Referencia o identificador del documento sobre el cual se marca el Log</param>
/// <param name="Log">String con información adicional</param>
/// <returns>bool</returns>
public static bool Log(int Empleado, string Equipo, TipoLog TLog, TipoTransaccion TTransaccion, string Requerimiento, short Modulo, string Referencia, string Log)
{
bool retVal = Convert.ToBoolean(SqlHelper.ExecuteScalar(
ESSeguridad.FormarStringConexion(), Queries.WF_InsertarLog,
Empleado,
Equipo,
TLog,
TTransaccion,
Requerimiento,
Modulo,
Referencia,
Log
));
return(retVal);
}
public Int32 Logar(TipoLog tipoLog, String mensagem, String stackTrace, String campo, String tipoErroFisico, DateTime dataHora, App aplicacao, Tela tela, Int32 cdLog)
{
Int32 cod = 0;
if (CaseBusiness.Framework.Configuracao.Configuracao.TipoComunicacao == TipoComunicacao.Local)
{
cod = new AcessoDados.Log().Logar(tipoLog, mensagem, stackTrace, campo, tipoErroFisico, dataHora, aplicacao, tela, cdLog);
}
else if (CaseBusiness.Framework.Configuracao.Configuracao.TipoComunicacao == TipoComunicacao.Remota)
{
//CaseWSFramework.FrameworkSoapClient fWS = new CaseWSFramework.FrameworkSoapClient();
//cod = fWS.Logar((CaseWSFramework.TipoLog)((Int32)(tipoLog)), mensagem, stackTrace, campo, tipoErroFisico, dataHora, (CaseWSFramework.App)((Int32)(aplicacao)), (CaseWSFramework.Tela)((Int32)(tela)), cdLog);
}
return(cod);
}
public static void Log(TipoLog tipoLog, string message)
{
switch (tipoLog)
{
case TipoLog.Info:
log.Info(message);
break;
case TipoLog.Warn:
log.Warn(message);
break;
case TipoLog.Error:
log.Error(message);
break;
}
}
public static void CreateLog(ModuloLog modulo, TipoObjeto origen, TipoLog tipo, string descripcion, string cambios = "")
{
try
{
UserLog userLog = new UserLog(modulo, origen, tipo, descripcion, cambios);
List <UserLog> list = GetUserLog();
list.Add(userLog);
string fileName = Path.Combine(AppInfo.AppPath, @"..\activity.dasp");
using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write))
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, list);
}
}
catch (Exception)
{
throw;
}
}
public static void CrearLog(string mensaje, TipoLog tipo, Exception ex = null)
{
//string ruta = ConfigurationManager.AppSettings["RutaLog"] ?? "C:\\";
//string archivo = string.Format("{0}\\tp2log.txt", ruta);
//using (FileStream fs = new FileStream(archivo, FileMode.Append, FileAccess.Write))
//{
// using (StreamWriter sw = new StreamWriter(fs, Encoding.UTF8))
// {
// sw.WriteLine(string.Format("{0} - {1}", tipo, DateTime.Now));
// sw.WriteLine(string.Format("{0}", mensaje));
// if (ex != null)
// {
// sw.WriteLine(string.Format("{0}", ex.Message));
// sw.WriteLine(string.Format("{0}", ex.StackTrace));
// }
// sw.WriteLine("=============================================");
// }
//}
}
internal void GravarLog(TipoLog tipo, string descricao)
{
using var context = new DatabaseContext();
context.Logs.Add(new Log()
{
Tipo = tipo,
Descricao = descricao,
PersonagemOrigem = 0,
IPOrigem = string.Empty,
SocialClubOrigem = 0,
PersonagemDestino = 0,
IPDestino = string.Empty,
SocialClubDestino = 0,
HardwareIdHashOrigem = 0,
HardwareIdHashDestino = 0,
HardwareIdExHashOrigem = 0,
HardwareIdExHashDestino = 0,
});
context.SaveChanges();
}
public Int32 Logar(TipoLog tipoLog, String mensagem, String stackTrace, String campo, String tipoErroFisico, DateTime dataHora, App aplicacao, Tela tela, Int64 cdLogTransacao)
{
Int32 log = 0;
List <Object> r = null;
try
{
persiste.AddParameter("@LOG_DS_MENSAGEM", mensagem);
persiste.AddParameter("@LOG_DS_STACK_TRACE", stackTrace);
persiste.AddParameter("@LOG_DS_CAMPO", campo.ToString());
persiste.AddParameter("@LOG_TP_ERRO_FISICO", tipoErroFisico);
persiste.AddParameter("@LOG_DH", dataHora);
//persiste.AddParameter("@T0082_CD_TELA", (Int32)tela);
persiste.AddParameter("@LOG_DS_APLICACAO", aplicacao.ToString());
if (cdLogTransacao > 0)
{
persiste.AddParameter("@MSG_ID", cdLogTransacao);
}
else
{
persiste.AddParameter("@MSG_ID", DBNull.Value);
}
persiste.AddParameter("@LOG_DS_TIPO", tipoLog.ToString());
persiste.AddParameter("@LOG_ID", Int32.MinValue, ParameterDirection.Output);
r = persiste.ExecuteNonQueryComRetorno(CommandType.StoredProcedure, "prLOG_INS");
log = Convert.ToInt32(r[0]);
}
catch (System.Exception ex)
{
CaseBusiness.Framework.Log.Log.LogarArquivo("Erro: " + ex.Message + " " + ex.StackTrace, CaseBusiness.Framework.Log.TipoEventoLog.Erro, "Case Framework");
throw;
}
return(log);
}
//private static readonly log4net.ILog Log = LogManager.GetLogger("Adapter.Adapter");
public void RegistraLog(string msg, TipoLog tipoLog)
{
if (Log == null)
{
Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
XmlConfigurator.Configure();//Apenas 1 vez
}
switch (tipoLog)
{
case TipoLog.Aviso:
Log.Warn(msg);
break;
case TipoLog.Informação:
Log.Info(msg);
break;
case TipoLog.Erro:
Log.Error(msg);
break;
default:
throw new ArgumentException();
}
}
public static List <Log> get(int count = DEFAULT_LOG_COUNT, TipoLog tipo = TipoLog.NULL)
{
Acceso db = new Acceso();
StringBuilder query = new StringBuilder();
if (count == 0)
{
count = DEFAULT_LOG_COUNT;
}
query.Append(" select top ");
query.Append(count);
query.Append(" * from Log ");
if (tipo != TipoLog.NULL)
{
query.Append(" where tipo = ");
query.Append(Cadenas.comillas(tipo.ToString().ToLower()));
}
query.Append(" order by clave desc ");
db.EjecutarQuery(query.ToString());
DataTable table = db.getTable();
List <Log> lista = new List <Log>();
foreach (DataRow r in table.Rows)
{
Log l = new Log();
l.llenarDatos(r);
lista.Insert(0, l);
}
return(lista);
}
public static bool logger(string tabla, TipoLog tipo, Hashtable datosOriginales)
{
if (datosOriginales == null)
{
return(true);
}
string usuario = HttpContext.Current.User.Identity.Name;
string timesamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
string tipoStr = tipo == TipoLog.Delete ? "D" : "U";
string datosOriginalesStr = "";
foreach (DictionaryEntry entry in datosOriginales)
{
datosOriginalesStr += String.Format("{0}={1}, ", entry.Key, entry.Value.ToString().Replace("'", ""));
}
string sql = String.Format(
"INSERT INTO mhistorial_cambios " +
"VALUES " +
"( " +
" DEFAULT, " +
" '{0}', " +
" '{1}', " +
" '{2}', " +
" '{3}', " +
" '{4}' " +
")",
tabla,
tipoStr,
datosOriginalesStr,
usuario,
timesamp);
return(DBFunctions.NonQuery(sql) == 1);
}
public static void add(TipoLog tipo, string log)
{
try
{
if (ToConsole)
{
Console.WriteLine(log);
return;
}
if (String.IsNullOrEmpty(log))
{
return;
}
for (int i = 0; i < log.Length; i += MAX_LOG_LEN)
{
string str;
if ((i + MAX_LOG_LEN) >= log.Length)
{
str = log.Substring(i);
}
else
{
str = log.Substring(i, MAX_LOG_LEN);
}
new Log(tipo, str).guardar();
}
}
catch (Exception)
{
// No queremos que al guardar los logs se genere una excepción
}
}
public static Int32 Logar(TipoLog tipoLog, String mensagem, String stackTrace, CaseBusiness.Framework.BancoDados.AcessoDadosBase acessoDados, String campo, String tipoErroFisico, DateTime dataHora, App aplicacao, Tela tela, Int32 cdLogTransacao)
{
Int32 cod = 0;
String parameters = "";
try
{
if (acessoDados != null)
{
if (acessoDados.Parameters != null)
{
foreach (DbParameter param in acessoDados.Parameters)
{
String direction = "";
if (param.Direction == System.Data.ParameterDirection.Input)
{
direction = "(I)";
}
else if (param.Direction == System.Data.ParameterDirection.Output)
{
direction = "(O)";
}
else if (param.Direction == System.Data.ParameterDirection.InputOutput)
{
direction = "(I/O)";
}
else
{
direction = "(RV)";
}
parameters += param.ParameterName + " " + param.Value.ToString() + " " + direction;
}
}
else
{
parameters = "AcessoDados.Parameters = NULL";
}
}
else
{
parameters = "AcessoDados = NULL";
}
CaseBusiness.Framework.Configuracao.Configuracao._erroInicializacao = mensagem + " " + parameters;
cod = new Processo.Log().Logar(tipoLog, mensagem + " " + parameters, stackTrace, campo, tipoErroFisico, dataHora, aplicacao, tela, cdLogTransacao);
}
catch (System.Exception ex)
{
switch (tipoLog)
{
case TipoLog.Sucesso:
LogarArquivo(mensagem, TipoEventoLog.Sucesso, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
break;
case TipoLog.Informacao:
LogarArquivo(mensagem, TipoEventoLog.Informacao, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
break;
case TipoLog.Aviso:
LogarArquivo(mensagem, TipoEventoLog.Aviso, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
break;
case TipoLog.Erro:
LogarArquivo(mensagem, TipoEventoLog.Erro, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
break;
}
LogarArquivo(ex.Message, TipoEventoLog.Erro, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
}
return(cod);
}
public void LogMensaje(TipoLog tipo, string mensaje, DateTime timeStamp)
{
LogMensaje(tipo, mensaje);
}
public void LogMensaje(TipoLog tipoLog, Exception ex)
{
LogMensaje(tipoLog, ex, ex.Message);
}
public void LogMensaje(TipoLog tipo, string mensaje)
{
string mensajeFinal = $"{GetTime()}- {tipo} - {mensaje}";
Console.WriteLine(mensajeFinal);
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="campo">O nome do campo que aparecerá no Log. Pode ter até 30 caracteres.</param>
public LogModelAttribute(TipoLog tipoLog, string campo)
: this(tipoLog, campo, false, null, null, null, null, false)
{
}
public void RegistrarLog(string mensagem, TipoLog tipoLog)
{
new LOG4NET().Write(mensagem);
}
internal Log(TipoLog tipo, string descricao)
{
Tipo = tipo;
Descricao = descricao;
Quando = DateTime.Now;
}
public bool Logar(string mensgem, TipoLog tipo)
{
return(_tiposLogsDisponiveis.Contains(tipo) && Task.Run(async() => await _serviceAgent.Post(mensgem)).Result);
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="campo">O nome do campo que aparecerá no Log. Pode ter até 30 caracteres.</param>
/// <param name="campoDescricaoModel">O nome da propriedade da Model que contém a descrição.</param>
/// <param name="tipoDAO">O tipo da DAO que contém a descrição.</param>
/// <param name="campoIdModel">O nome da propriedade da Model que contém o ID.</param>
/// <param name="nomeMetodoDAO">O nome do método que retorna o item da DAO.</param>
/// <param name="incluirValorPrimeiroParametro">O valor do item deve ser incluído como o primeiro parâmetro?</param>
/// <param name="parametrosMetodoDAO">Os parâmetros do método de retorno.</param>
public LogModelAttribute(TipoLog tipoLog, string campo, string campoDescricaoModel, Type tipoDAO, string campoIdModel,
string nomeMetodoDAO, bool incluirValorPrimeiroParametro, params object[] parametrosMetodoDAO)
: this(tipoLog, campo, false, campoDescricaoModel, tipoDAO, campoIdModel, nomeMetodoDAO, incluirValorPrimeiroParametro, parametrosMetodoDAO)
{
}
public void RegistraLog(string msg, TipoLog tipoLog)
{
Console.WriteLine("Log Antigo");
Console.WriteLine(msg);
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="campo">O nome do campo que aparecerá no Log. Pode ter até 30 caracteres.</param>
public LogModelAttribute(TipoLog tipoLog, string campo, bool isCampoEFD)
: this(tipoLog, campo, isCampoEFD, null, null, null, null, false)
{
}
public static Int32 Logar(TipoLog tipoLog, String mensagem, String stackTrace, String campo, String tipoErroFisico, DateTime dataHora, App aplicacao, Tela tela, Int32 cdLogTransacao)
{
#if DEBUG
switch (tipoLog)
{
case TipoLog.Sucesso:
Console.BackgroundColor = ConsoleColor.DarkGreen;
break;
case TipoLog.Informacao:
Console.BackgroundColor = ConsoleColor.DarkBlue;
break;
case TipoLog.Aviso:
Console.BackgroundColor = ConsoleColor.DarkYellow;
break;
case TipoLog.Erro:
Console.BackgroundColor = ConsoleColor.DarkRed;
break;
}
Console.WriteLine(dataHora.ToString("dd/MM/yyyy HH:mm:ss.fff") + " " + tipoLog.ToString() + "-" + mensagem);
if (!String.IsNullOrEmpty(stackTrace))
{
Console.WriteLine(dataHora.ToString("dd/MM/yyyy HH:mm:ss.fff") + " " + tipoLog.ToString() + "-" + stackTrace);
}
Console.BackgroundColor = ConsoleColor.Black;
#endif
Int32 cod = 0;
try
{
lock (locker)
{
CaseBusiness.Framework.Configuracao.Configuracao._erroInicializacao = mensagem;
cod = new Processo.Log().Logar(tipoLog, mensagem, stackTrace, campo, tipoErroFisico, dataHora, aplicacao, tela, cdLogTransacao);
}
}
catch (System.Exception ex)
{
switch (tipoLog)
{
case TipoLog.Sucesso:
LogarArquivo(mensagem, TipoEventoLog.Sucesso, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
break;
case TipoLog.Informacao:
LogarArquivo(mensagem, TipoEventoLog.Informacao, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
break;
case TipoLog.Aviso:
LogarArquivo(mensagem, TipoEventoLog.Aviso, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
break;
case TipoLog.Erro:
LogarArquivo(mensagem, TipoEventoLog.Erro, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
break;
}
LogarArquivo(ex.Message, TipoEventoLog.Erro, CaseBusiness.Framework.Configuracao.Configuracao.NomeAplicacao);
}
return(cod);
}
public string Registrar(TipoLog informacao,string mensagem)
{
return "IDLog";
}
private Log(TipoLog tipo, string log)
{
this.tipo = tipo;
this.log = log;
this.timestamp = DateTime.Now;
}
public string Registrar(TipoLog informacao, string mensagem)
{
return("IDLog");
}
public Boolean Inserir(string pStrMensagem, TipoLog pEnumTipo)
{
string mensagem = pStrMensagem;
string linha = String.Empty;
string caminhoArquivo = String.Empty;
string nomeArquivo = String.Empty;
StreamWriter sw = null;
try
{
if (mensagem == null)
{
mensagem = string.Empty;
}
//OBTÉM O CAMINHO DO ARQUIVO
caminhoArquivo = ObterCaminhoDoArquivoDeLog();
//TESTANDO PARA VER SE O DIRETÓRIO EXISTE
if (!Directory.Exists(caminhoArquivo))
{
Directory.CreateDirectory(caminhoArquivo);
}
//OBTÉM O NOME DO ARQUIVO
nomeArquivo = ObterNomeDoArquivoDeLog();
//Define o caminho completo do arquivo de log pela primeira vez
if (String.IsNullOrEmpty(gStrCaminhoArquivoCompleto))
{
gStrCaminhoArquivoCompleto = caminhoArquivo + "\\" + nomeArquivo;
}
switch (pEnumTipo)
{
case TipoLog.AVISO:
linha = "[AVISO] [" + System.Environment.UserName + " - " + System.Environment.MachineName + "]";
break;
case TipoLog.ERRO:
linha = "[ERRO] [" + System.Environment.UserName + " - " + System.Environment.MachineName + "]";
break;
default: break;
}
linha = linha + " " + DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss");
linha = linha + " --> " + mensagem;
//ESCREVE O ARQUIVO
sw = new StreamWriter(gStrCaminhoArquivoCompleto, true);
sw.WriteLine(linha);
sw.Close();
return(true);
}
catch (Exception ex)
{
gObjExcecao = ex;
return(false);
}
finally
{
if (sw != null)
{
sw.Close();
sw.Dispose();
sw = null;
}
}
}
public void RegistrarLog(String mensagem, TipoLog tipoLog)
{
Console.WriteLine("Log gravado com");
}
public void RegistrarLog(string mensagem, TipoLog tipoLog)
{
new LOG4NET().Write(mensagem);
}
public void RegistrarLog(String mensagem,TipoLog tipoLog)
{
Console.WriteLine("Log gravado com");
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="campo">O nome do campo que aparecerá no Log. Pode ter até 30 caracteres.</param>
/// <param name="campoDescricaoModel">O nome da propriedade da Model que contém a descrição.</param>
/// <param name="tipoDAO.Instance">O tipo da DAO que contém a descrição.</param>
public LogModelAttribute(TipoLog tipoLog, string campo, bool isCampoEFD, string campoDescricaoModel, Type tipoDAO)
: this(tipoLog, campo, isCampoEFD, campoDescricaoModel, tipoDAO, null, null, false)
{
}
public void RegistrarLog(string mensagem, TipoLog tipoLog)
{
Console.WriteLine("log padrão da aplicação {0} {1}", mensagem,tipoLog);
}
