albert/kreta
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

init

Browse source
This commit is contained in:
skidoodle 2024-03-13 00:33:46 +01:00
commit e124a47765
19374 changed files with 9806149 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

216
Framework/Logging/ConsoleLogWriter.cs Normal file
View file

@ -0,0 +1,216 @@
using System;
using System.Diagnostics;
namespace Kreta.Framework.Logging
{
/// <summary>
/// Konzol naplóvezető.
/// </summary>
public sealed class ConsoleLogWriter : LogWriterBase
{
const ConsoleColor _defaultConsoleColor = ConsoleColor.Gray;
const ConsoleColor _entrySeparatorColor = ConsoleColor.Cyan;
const string _entrySeparator = ">> ";
static readonly object _syncRoot = new object();
static ConsoleLogWriter()
{
SetDebug();
}
[Conditional("DEBUG")]
static void SetDebug()
{
DebugEnabled = true;
}
/// <summary>
/// Visszaadja a naplózási szinthez tartozó színt.
/// </summary>
/// <param name="level">A naplózási szint</param>
/// <returns></returns>
static ConsoleColor GetConsoleForegroundColor(LogLevel level)
{
switch (level)
{
case LogLevel.DEBUG:
{
return ConsoleColor.Gray;
}
case LogLevel.INFO:
{
return ConsoleColor.Green;
}
case LogLevel.WARNING:
{
return ConsoleColor.Yellow;
}
case LogLevel.ERROR:
{
return ConsoleColor.Red;
}
case LogLevel.FATAL:
{
return ConsoleColor.Magenta;
}
default:
{
return _defaultConsoleColor;
}
}
}
/// <summary>
/// Konzolra és a Debug-ra írja a megadott szöveget. Sortöréssel.
/// </summary>
/// <param name="messageText">A kiírandó szöveg</param>
/// <param name="level">A naplózási szint</param>
public static void WriteLine(string messageText, LogLevel level)
{
WriteLineToDebug(messageText, level);
WriteLineToConsole(messageText, level, false);
}
/// <summary>
/// Konzolra és a Debug-ra írja a megadott szöveget.
/// </summary>
/// <param name="messageText">A kiírandó szöveg</param>
/// <param name="level">A naplózási szint</param>
public static void Write(string messageText, LogLevel level)
{
WriteToDebug(messageText, level);
WriteToConsole(messageText, level);
}
/// <summary>
/// Konzolra ír egy üzenetet. Sortöréssel
/// </summary>
/// <param name="messageText">Az üzenet szövege</param>
public static void WriteLine(string messageText)
{
WriteLine(messageText, LogLevel.UNKNOWN);
}
/// <summary>
/// Konzolra ír egy üzenetet.
/// </summary>
/// <param name="messageText">Az üzenet szövege</param>
public static void Write(string messageText)
{
Write(messageText, LogLevel.UNKNOWN);
}
/// <summary>
/// Naplóba vezeti az üzenetet.
/// </summary>
/// <param name="message">A naplóba vezetendő üzenet</param>
protected override Guid? DoLog(ILogMessage message)
{
string messagetext = LogUtil.FormatMessageCompact(message);
WriteLineToDebug(messagetext, message.Level);
WriteLineToConsole(messagetext, message.Level, true);
return null;
}
protected override void DoLog(ILogMessage message, Guid logId)
{
DoLog(message);
}
#region inneroperations
static void WriteToConsole(string messagetext, LogLevel level)
{
if (!ConsoleEnabled)
{
return;
}
lock (_syncRoot)
{
Console.ForegroundColor = GetConsoleForegroundColor(level);
Console.WriteLine(messagetext);
Console.ForegroundColor = _defaultConsoleColor;
}
}
static void WriteLineToConsole(string messagetext, LogLevel level, bool islog)
{
if (!ConsoleEnabled)
{
return;
}
lock (_syncRoot)
{
if (islog)
{
Console.ForegroundColor = _entrySeparatorColor;
Console.Write(_entrySeparator);
}
Console.ForegroundColor = GetConsoleForegroundColor(level);
Console.WriteLine(messagetext);
Console.ForegroundColor = _defaultConsoleColor;
}
}
static void WriteToDebug(string messagetext, LogLevel level)
{
if (!DebugEnabled)
{
return;
}
switch (level)
{
case LogLevel.DEBUG:
Debug.Write(messagetext);
break;
case LogLevel.ERROR:
case LogLevel.FATAL:
Trace.TraceError(messagetext);
break;
case LogLevel.WARNING:
Trace.TraceWarning(messagetext);
break;
default:
Trace.TraceInformation(messagetext);
break;
}
}
static void WriteLineToDebug(string messagetext, LogLevel level)
{
if (!DebugEnabled)
{
return;
}
switch (level)
{
case LogLevel.DEBUG:
Debug.WriteLine(messagetext);
break;
case LogLevel.ERROR:
case LogLevel.FATAL:
Trace.TraceError(messagetext);
break;
case LogLevel.WARNING:
Trace.TraceWarning(messagetext);
break;
default:
Trace.TraceInformation(messagetext);
break;
}
}
#endregion
/// <summary>
/// Engedélyezi vagy tiltja a konzolra való naplózást. Alapértelmezésben tiltott.
/// </summary>
public static bool ConsoleEnabled { get; set; }
/// <summary>
/// Engedélyezi vagy tiltja a debug-ra való naplózást. Alapértelmezésben tiltott.
/// </summary>
public static bool DebugEnabled { get; set; }
}
}

166
Framework/Logging/DatabaseLogWriter.cs Normal file
View file

@ -0,0 +1,166 @@
using System;
namespace Kreta.Framework.Logging
{
/// <summary>
/// Adatbázis naplóvezető osztály.
/// </summary>
public sealed class DatabaseLogWriter : LogWriterBase
{
private string m_ConnectionString;
private string m_ServerName;
private const string insertCommandText = @"
INSERT INTO T_LOG (C_TIMESTAMP, C_SERVER, C_EVENTTYPEID, C_LEVELID, C_SESSIONID, C_DETAILS, C_GENERATEDID, SERIAL)
VALUES (GETDATE(), :pSERVER, :pEVENTTYPE, :pLEVEL, :pSESSIONID, :pDETAILS, :pGENERATEDID, 0)";
private const string insertCommandTextWithIntezmeny = @"
INSERT INTO T_LOG (C_TIMESTAMP, C_SERVER, C_EVENTTYPEID, C_LEVELID, C_SESSIONID, C_DETAILS, C_GENERATEDID, C_INTEZMENYID, C_TANEVID, SERIAL)
VALUES (GETDATE(), :pSERVER, :pEVENTTYPE, :pLEVEL, :pSESSIONID, :pDETAILS, :pGENERATEDID, :pINTEZMENYID, :pTANEVID, 0)";
/// <summary>
/// Az osztály konstruktora.
/// </summary>
/// <param name="connectionString">Az adatbázis kapcsolatot leíró karakterlánc</param>
/// <param name="serverName">A naplózót használó kiszolgáló neve</param>
public DatabaseLogWriter(string connectionString, string serverName)
{
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentNullException(nameof(connectionString));
}
if (string.IsNullOrWhiteSpace(serverName))
{
throw new ArgumentNullException(nameof(serverName));
}
m_ConnectionString = connectionString;
m_ServerName = serverName;
}
private string ConnectionString
{
get
{
return m_ConnectionString;
}
}
/// <summary>
/// Naplóba vezeti az üzenetet.
/// </summary>
/// <param name="message">A naplóba vezetendő üzenet</param>
protected override Guid? DoLog(ILogMessage message)
{
var logId = Guid.NewGuid();
DbLog(message, logId);
return logId;
}
protected override void DoLog(ILogMessage message, Guid logId)
{
DbLog(message, logId);
}
private bool ActivateContext()
{
if (UserContext.Instance == null || !UserContext.Instance.Activated)
{
SDAServer.Instance.SessionManager.ActivateSystemSession();
return true;
}
return false;
}
private void DbLog(ILogMessage message, Guid logId)
{
if (message.Level < LogLevel.INFO)
{
// DEBUG-ot nem tolunk le adatbázisba!
return;
}
var sessionActivated = ActivateContext();
try
{
int? intezmenyId = null;
int? tanevId = null;
var commandText = insertCommandText;
if (UserContext.Instance != null && UserContext.Instance.IntezmenyId > 0)
{
commandText = insertCommandTextWithIntezmeny;
intezmenyId = UserContext.Instance.IntezmenyId;
if (UserContext.Instance.AktivTanevId > 0)
{
tanevId = UserContext.Instance.AktivTanevId;
}
}
using (SDA.DataProvider.SDAConnection connection = new SDA.DataProvider.SDAConnection(ConnectionString))
{
using (SDA.DataProvider.SDACommand command = connection.CreateCommand())
{
command.CommandText = commandText;
if (intezmenyId.HasValue)
{
command.Parameters.Add("pINTEZMENYID", intezmenyId.Value);
if (tanevId.HasValue)
{
command.Parameters.Add("pTANEVID", tanevId.Value);
}
else
{
command.Parameters.Add("pTANEVID", DBNull.Value);
}
}
command.Parameters.Add("pSERVER", SDA.DataProvider.SDADBType.String, 36).Value = m_ServerName;
command.Parameters.Add("pEVENTTYPE", SDA.DataProvider.SDADBType.Int, 9).Value = message.EventType;
command.Parameters.Add("pLEVEL", SDA.DataProvider.SDADBType.Int, 9).Value = message.Level;
command.Parameters.Add("pGENERATEDID", logId);
command.Parameters.Add("pSESSIONID", SDA.DataProvider.SDADBType.String, 36).Value = message.SessionId == null ? DBNull.Value : (object)message.SessionId;
string details = LogUtil.FormatMessageDetails(message, "\r\n");
if (string.IsNullOrWhiteSpace(details))
{
command.Parameters.Add("pDETAILS", SDA.DataProvider.SDADBType.LongString).Value = DBNull.Value;
}
else
{
command.Parameters.Add("pDETAILS", SDA.DataProvider.SDADBType.LongString).Value = details;
}
connection.Open();
command.ExecuteNonQuery();
}
}
}
catch (SDA.DataProvider.SDADataProviderException exception)
{
if (exception.Error == SDA.DataProvider.SDADataProviderError.CommunicationError)
{
return;
}
if (exception.Error == SDA.DataProvider.SDADataProviderError.UniqueKeyViolation)
{
// ezt a kivételt nyugodtan lenyelhetjük
return;
}
throw;
}
finally
{
if (sessionActivated)
{
if (UserContext.Instance != null && UserContext.Instance.Activated)
{
SDAServer.Instance.SessionManager.DeactivateSystemSession();
}
}
}
}
}
}

29
Framework/Logging/ErrorCodeAttribute.cs Normal file
View file

@ -0,0 +1,29 @@
using System;
namespace Kreta.Framework.Logging
{
/// <summary>
/// Az attribútum az esemény (kivétel) kódját definiálja.
/// </summary>
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
public sealed class ErrorCodeAttribute : Attribute
{
/// <summary>
/// Az osztály konstruktora
/// </summary>
/// <param name="errorcode">Hibakód</param>
public ErrorCodeAttribute(Events errorCode)
{
ErrorCode = errorCode;
}
/// <summary>
/// Hibakód
/// </summary>
public Events ErrorCode
{
get;
private set;
}
}
}

581
Framework/Logging/Events.cs Normal file
View file

@ -0,0 +1,581 @@
namespace Kreta.Framework
{
/// <summary>
/// Naplózható események felsorolása.
/// </summary>
public enum Events
{
/// <summary>
/// Általános vagy ismeretlen esemény.
/// </summary>
/// <remarks>Akkor használjuk, amikor nincs megfelelő típus ebben a felsorolásban.</remarks>
GENERAL = 0,
/// <summary>
/// Nem programozó által kiváltott kivétel
/// </summary>
SYSTEM_EXCEPTION = 1000,
/// <summary>
/// Olyan kivétel ami rendkívül súlyos
/// </summary>
CRITICAL_EXCEPTION = 1001,
/// <summary>
/// Olyan kivétel ami az SDA.DataProvider-től származik
/// </summary>
DATAPROVIDER_EXCEPTION = 1002,
/// <summary>
/// Jobütemező kivétele
/// </summary>
SCHEDULER_EXCEPTION = 1003,
/// <summary>
/// Tárolt hívó kivétel
/// </summary>
PROGRAMMABILITY_EXCEPTION = 1004,
/// <summary>
/// Szabolcs féle adatbázis státusz riport a rendelkezésre álló helyről
/// </summary>
DB_TABLESPACE_WARNING = 2000,
LICENSE_SUCCESS = 3000,
LICENSE_ERROR = 3001,
LICENSE_WARNING = 3002,
UPDATE_INFO = 4000,
UPDATE_ERROR = 4001,
WEB_ERROR_REPORT = 5000,
#region Keretrendszer események
/// <summary>
/// Általános keretrendszer esemény.
/// </summary>
FRAMEWORK_GENERAL = 10001,
/// <summary>
/// Érvénytelen konfiguráció
/// </summary>
FRAMEWORK_CONFIG_INVALIDCONFIG = 10002,
/// <summary>
/// Általános keretrendszeri adatbázishiba.
/// </summary>
FRAMEWORK_DB_GENERAL = 10003,
/// <summary>
/// Adatbázis-kiszolgáló nem található.
/// </summary>
FRAMEWORK_DB_SERVERNOTFOUND = 10004,
/// <summary>
/// Általános munkamenet-hiba.
/// </summary>
FRAMEWORK_SESSION_GENERAL = 10005,
/// <summary>
/// Munkamenet nem hozható létre.
/// </summary>
FRAMEWORK_SESSION_CANNOTCREATE = 10006,
/// <summary>
/// Érvénytelen munkamenet.
/// </summary>
FRAMEWORK_SESSION_INVALID = 10007,
/// <summary>
/// A munkamenet-kezelő nem tudott elindulni.
/// </summary>
FRAMEWORK_SESSION_CANNOTSTART = 10008,
/// <summary>
/// A munkement-kezelő nem tudott leállni.
/// </summary>
FRAMEWORK_SESSION_CANNOTSTOP = 10009,
/// <summary>
/// Felhasználói kontextus nem hozható létre.
/// </summary>
FRAMEWORK_USERCONTEXT_CANNOTCREATE = 10010,
/// <summary>
/// Felhasználói kontextus érvénytelen.
/// </summary>
FRAMEWORK_USERCONTEXT_INVALID = 10011,
/// <summary>
/// A kiszolgáló elindult
/// </summary>
FRAMEWORK_SERVERSTART = 10012,
/// <summary>
/// A kiszolgáló leállt.
/// </summary>
FRAMEWORK_SERVERSTOP = 10013,
/// <summary>
/// A kiszolgáló betöltötte a konfigurációt.
/// </summary>
FRAMEWORK_CONFIGLOADED = 10014,
/// <summary>
/// Munkamenet létrehozás.
/// </summary>
FRAMEWORK_SESSIONCREATED = 10015,
/// <summary>
/// Munkamenet törlés.
/// </summary>
FRAMEWORK_SESSIONDELETED = 10016,
/// <summary>
/// Munkamenet elévülés.
/// </summary>
FRAMEWORK_SESSIONEXPIRED = 10017,
/// <summary>
/// Kivétel történt.
/// </summary>
FRAMEWORK_EXCEPTION = 10018,
/// <summary>
/// Entitás előélet mentése sikertelen.
/// </summary>
FRAMEWORK_ENTITYHISTORYFAILED = 10019,
/// <summary>
/// Tranzakció kezdeményezése.
/// </summary>
FRAMEWORK_BEGINTRANSACTION = 10020,
/// <summary>
/// Tranzakció jóváhagyás.
/// </summary>
FRAMEWORK_COMMITTRANSACTION = 10021,
/// <summary>
/// Tranzakció visszagörgetés.
/// </summary>
FRAMEWORK_ROLLBACKTRANSACTION = 10022,
/// <summary>
/// Kiszolgáló terheltsége.
/// </summary>
FRAMEWORK_SERVERLOAD = 10023,
/// <summary>
/// A kiszolgáló munkameneteinek törlése.
/// </summary>
FRAMEWORK_SESSIONCLEANUP = 10024,
/// <summary>
/// Sikertelen naplózás.
/// </summary>
FRAMEWORK_LOGFAILED = 10025,
/// <summary>
/// Sérült adat integritás.
/// </summary>
FRAMEWORK_DATAINTEGRITYVIOLATION = 10026,
/// <summary>
/// Hivatkozás nemlétező tranzakcióra.
/// </summary>
FRAMEWORK_NOTINTRANSACTION = 10027,
/// <summary>
/// Munkement korlát elérése.
/// </summary>
FRAMEWORK_SESSIONLIMITREACHED = 10028,
/// <summary>
/// Külső kulcs megsértése.
/// </summary>
FRAMEWORK_DB_FOREIGNKEYVIOLATION = 10029,
/// <summary>
/// Egyediség megsérétse.
/// </summary>
FRAMEWORK_DB_UNIQUEKEYVIOLATION = 10030,
/// <summary>
/// Leállítási kérelem (regisztrált szerver esetén)
/// </summary>
FRAMEWORK_SERVER_STOPPING = 10031,
/// <summary>
/// Érvényes felhasználói belépés
/// </summary>
FRAMEWORK_USER_LOGIN = 10033,
/// <summary>
/// Felhasználó szerepkörválasztás
/// </summary>
FRAMEWORK_USER_SETROLE = 10034,
/// <summary>
/// Deadlock.
/// </summary>
FRAMEWORK_DB_DEADLOCK = 10035,
#endregion
#region Akciókkal kapcsolatos események
/// <summary>
/// Általános vagy ismeretlen, akcióval kapcsolatos esemény.
/// </summary>
ACTION_GENERAL = 20001,
/// <summary>
/// Érvénytelen kérés
/// </summary>
ACTION_INVALIDREQUEST = 20002,
/// <summary>
/// Befejezetlen művelet.
/// </summary>
ACTION_INCOMPLETED = 20003,
/// <summary>
/// Nem létező művelet.
/// </summary>
ACTION_NOTFOUND = 20004,
/// <summary>
/// Akció futtatás
/// </summary>
ACTION_EXECUTE = 20005,
/// <summary>
/// Érvénytelen mező hossz
/// </summary>
ACTION_INVALID_FIELD_LENGTH = 20006,
#endregion
#region WindowsService
/// <summary>
/// Windows service / Pharos sikeres hívás
/// </summary>
WINDOWSSERVICEEXECUTE = 21000,
/// <summary>
/// Windows service / Pharos hiba
/// </summary>
WINDOWSSERVICEERROR = 21001,
#endregion
#region Entitásokkal kapcsolatos események
/// <summary>
/// Általános entitás esemény.
/// </summary>
ENTITY_GENERAL = 30001,
/// <summary>
/// Entitás nem található.
/// </summary>
ENTITY_NOTFOUND = 30002,
/// <summary>
/// Érvénytelen adat.
/// </summary>
ENTITY_INVALIDDATA = 30003,
/// <summary>
/// Érvénytelen entitás állapot.
/// </summary>
ENTITY_INVALIDSTATE = 30004,
ENTITY_LOAD = 30005,
ENTITY_INSERT = 30006,
ENTITY_UPDATE = 30007,
ENTITY_DELETE = 30008,
ENTITY_MODIFY = 30009,
/// <summary>
/// Érvénytelen entitásverzió.
/// </summary>
ENTITY_EXPIREDVERSION = 30010,
/// <summary>
/// Csak olvasható mezőre történt írási kísérlet.
/// </summary>
ENTITY_READONLYATTRIBUTE = 30011,
/// <summary>
/// Az entitás törlése sikertelen, mert vannak kapcsolódásai.
/// </summary>
ENTITY_DELETEFAILED = 30012,
/// <summary>
/// Az entitás törlése sikertelen, mert vannak kapcsolódásai.
/// </summary>
ENTITY_READONLY = 30013,
ENTITY_INVALIDXML = ACTION_INVALIDREQUEST,
#endregion
#region Jogosultságrendszerrel kapcsolatos események
/// <summary>
/// Általános jogosultságrendszer esemény.
/// </summary>
SECURITY_GENERAL = 40001,
/// <summary>
/// Írás jogosultság megsértése.
/// </summary>
SECURITY_WRITE = 40002,
/// <summary>
/// Érvénytelen művelet.
/// </summary>
SECURITY_INVALIDOPERATION = 40003,
/// <summary>
/// Sikertelen bejelentkezési kísérlet.
/// </summary>
SECURITY_LOGINFAILED = 40004,
/// <summary>
/// Érvénytelen szerepkör.
/// </summary>
SECURITY_INVALIDROLE = 40005,
/// <summary>
/// Oszlopjogosultság megsértése.
/// </summary>
SECURITY_COLUMNVIOLATION = 40006,
/// <summary>
/// Belépési követelmények nem teljesülése.
/// </summary>
SECURITY_LOGINREQUIREMENTFAILED = 40007,
/// <summary>
/// Érvénytelen helyettesített szemény.
/// </summary>
SECURITY_INVALIDSUBEMPLOYEEID = 40008,
/// <summary>
/// Abban az esetben dobjuk ezt az exceptiont, ha olyan szerepkörrel próbál meg jogosultságot kiosztani,
/// aminek nincs prioritása.
/// </summary>
SECURITY_INVALIDPRIORITY = 40009,
/// <summary>
/// Active directory-val kapcsolatos hibák
/// </summary>
SECURITY_ACTIVEDIRECTORY = 40010,
/// <summary>
/// Hibás Active Directory login/jelszó
/// </summary>
SECURITY_ACTIVEDIRECTORY_LOGINFAILED = 40011,
#endregion
#region SQL-lel kapcsolatos események
/// <summary>
/// Általános SQL esemény.
/// </summary>
SQL_GENERAL = 50001,
/// <summary>
/// SQL futtatása.
/// </summary>
SQL_EXECUTED = 50002,
#endregion
/// <summary>
/// Általános Neptun üzleti logkai esemény.
/// </summary>
NEPTUN_GENERAL = 60000,
#region Poszeidon
/// <summary>
/// Általános Poszeidon üzleti logkai esemény.
/// </summary>
POSZEIDON_GENERAL = 65000,
///// <summary>
///// A meghívott fájlszerver nem áll rendelkezésre.
///// </summary>
FAJLSZERVER_REQUESTEDFILESERVERINACTIVE = 65004,
/// <summary>
/// Minden neptunos behívást erre a kódra naplózunk.
/// </summary>
NEPTUN_CONNECTOR_EVENT = 65010,
/// <summary>
/// Ha egy neptunos behívásnál hiba történik.
/// </summary>
NEPTUN_CONNECTOR_ERROR = 65011,
/// <summary>
/// Moreq2 import hiba.
/// </summary>
MOREQ2_IMPORT = 65012,
/// <summary>
/// Moreq2 esemény.
/// </summary>
MOREQ2 = 65013,
/// <summary>
/// Az alapértelmezett EntityHistoryMode változásának eseménye.
/// </summary>
ENTITYHISTORYMODE = 65014,
/// <summary>
/// A lapolvasónál dobott warningtípus.
/// </summary>
SCANNER_ERROR = 65015,
#endregion
/// <summary>
/// Általános FDL esemény.
/// </summary>
FDL_GENERAL = 70000,
/// <summary>
/// Érvénytelen FDL szűrő.
/// </summary>
FDL_BAD_FILTER = 70001,
/// <summary>
/// Egyéb esemény.
/// </summary>
CUSTOM_HANDLABLE = 80000,
/// <summary>
/// Fejlesztő által feldobott esemény, az általa megadott szöveggel
/// </summary>
DEVELOPER_DEFINIED = 80001,
/// <summary>
/// SMS általános log esemény
/// </summary>
SMS_GENERAL = 81000,
/// <summary>
/// EMAIL általános log esemény
/// </summary>
EMAIL_GENERAL = 82000,
/// <summary>
/// Felhasználó (alkalmazott, hallgató) összevonásakor SQL (update, insert) utasítás generálása,
/// amivel vissza lehet állítani a régi állapotot
/// általános log esemény
/// </summary>
USER_COLLAPSE = 83000,
/// <summary>
/// Felhasználó (alkalmazott, hallgató) összevonásakor keletkező hibához log esemény.
/// </summary>
USER_COLLAPSE_ERROR = 83001,
/// <summary>
/// Fájl szerverrel kapcsolatos log események
/// </summary>
FAJLSZERVER_GENERAL = 84000,
/// <summary>
/// Értesítés feldolgozás általános log esemény
/// </summary>
MESSAGEMANAGER_GENERAL = 85000,
/// <summary>
/// verziófrissítés naplója
/// </summary>
NEPTUN_RELEASE = 90001,
/// <summary>
/// adatbázis összehasonlítás naplója
/// </summary>
NEPTUN_COMPARE = 90002,
/// <summary>
/// egyéb naplózást kívánó scriptek futásának naplója
/// </summary>
NEPTUN_SCRIPTS = 90003,
/// <summary>
/// adatbázis ellenőrző scriptek erdeménye pl.(táblatér)
/// </summary>
NEPTUN_DBCHECK = 90004,
/// <summary>
/// egyéb riportok, statisztikák futásának eredményei
/// </summary>
NEPTUN_REPORTS = 90005,
#region LMS
/// <summary>
/// LMS hiba
/// </summary>
LMS_ERROR = 100000,
#endregion
/// <summary>
/// fir 2.0 omkod valtozas rogzitesehez
/// </summary>
OM_CODE_CHANGED = 110000,
#region Kliens oldali események
/// <summary>
/// Kliens oldali kivétel
/// </summary>
CLIENT_GENERAL = 120000,
#endregion
/// <summary>
/// Job ütemezés
/// </summary>
JOB_SCHEDULE = 130000,
/// <summary>
/// Job futtatás
/// </summary>
JOB_EXECUTE = 130001,
#region MobileService
/// <summary>
/// Mobile sikeres hívás
/// </summary>
MOBILESERVICEEXECUTE = 140000,
/// <summary>
/// Mobile service hiba
/// </summary>
MOBILESERVICEERROR = 140001,
#endregion
/// <summary>
/// fir2 diakigeny kontener feloldasanak rogzitese
/// </summary>
DIAKIGENY_KONTENER = 150000,
Tanulo_KIR_Import = 160000,
Tanar_KIR_Import = 160001,
Tanevrend_Import = 160002,
DiakolimpiaCsomag = 160010
}
}

44
Framework/Logging/ILogMessage.cs Normal file
View file

@ -0,0 +1,44 @@
using System.Collections;
namespace Kreta.Framework.Logging
{
/// <summary>
/// Naplóüzenet felülete.
/// </summary>
public interface ILogMessage
{
/// <summary>
/// Naplózási szint
/// </summary>
LogLevel Level { get; }
/// <summary>
/// Naplóbejegyzés azonosítója (GUID)
/// </summary>
string LogEntryId { get; }
/// <summary>
/// Az esemény típusa
/// </summary>
Events EventType { get; }
/// <summary>
/// Munkamenet azonosítója
/// </summary>
string SessionId { get; }
/// <summary>
/// A bejegyzés naplóba lett-e már írva, vagy sem.
/// </summary>
bool IsLogged { get; set; }
/// <summary>
/// A naplóüzenet paraméterei
/// </summary>
IDictionary Parameters { get; }
int? IntezmenyId { get; }
int? TanevId { get; }
}
}

23
Framework/Logging/ILogWriter.cs Normal file
View file

@ -0,0 +1,23 @@
using System;
namespace Kreta.Framework.Logging
{
/// <summary>
/// Naplóvezetők felülete.
/// </summary>
public interface ILogWriter
{
/// <summary>
/// Naplóba ír egy naplóbejegyzést.
/// </summary>
/// <param name="message">A naplóbejegyzés</param>
Guid? Log(ILogMessage message);
/// <summary>
/// Logs the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="logId">The log identifier.</param>
void Log(ILogMessage message, Guid logId);
}
}

38
Framework/Logging/LogLevel.cs Normal file
View file

@ -0,0 +1,38 @@
namespace Kreta.Framework.Logging
{
/// <summary>
/// Naplózási szintek
/// </summary>
public enum LogLevel
{
/// <summary>
/// Ismeretlen
/// </summary>
UNKNOWN = 0,
/// <summary>
/// Nyomkövetés, ez a legrészletesebb naplózás, minden naplózásra kerül
/// </summary>
DEBUG = 1,
/// <summary>
/// Minden esemény naplózásra kerül, kivéve a nyomkövetést segítő naplóüzenetek.
/// </summary>
INFO = 2,
/// <summary>
/// Csak a figyelmeztetések, a hibák és a végzetes hibák kerülnek bele a naplóba.
/// </summary>
WARNING = 3,
/// <summary>
/// Csak a hibák és a végzetes hibák kerülnek bele a naplóba.
/// </summary>
ERROR = 4,
/// <summary>
/// Csak a végzetes hibák kerülnek bele a naplóba.
/// </summary>
FATAL = 5
}
}

29
Framework/Logging/LogLevelAttribute.cs Normal file
View file

@ -0,0 +1,29 @@
using System;
namespace Kreta.Framework.Logging
{
/// <summary>
/// Az attribútum az esemény (kivétel) kódját definiálja.
/// </summary>
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
public sealed class LogLevelAttribute : Attribute
{
/// <summary>
/// Az osztály konstruktora
/// </summary>
/// <param name="loglevel">Naplózási szint</param>
public LogLevelAttribute(LogLevel logLevel)
{
LogLevel = logLevel;
}
/// <summary>
/// Naplózási szint
/// </summary>
public LogLevel LogLevel
{
get;
private set;
}
}
}

182
Framework/Logging/LogMessage.cs Normal file
View file

@ -0,0 +1,182 @@
using System;
using System.Collections;
namespace Kreta.Framework.Logging
{
/// <summary>
/// Az <see cref="ILogMessage"/> interfész alapértelmezett implementációja
/// </summary>
public class LogMessage : ILogMessage
{
private string m_LogEntryId;
private Events m_EventType = 0;
private string m_SessionId = "";
private LogLevel m_Level;
private Hashtable m_Parameters = new Hashtable();
private string m_UserId;
private bool m_IsLogged;
int? intezmenyid; // TODO: kezelni értelmesen
int? tanevid; // TODO: kezelni értelmesen
/// <summary>
/// Az osztály alapértelmezett konstruktora.
/// </summary>
public LogMessage()
: this(Guid.NewGuid().ToString())
{
}
/// <summary>
/// Az osztály konstruktora.
/// </summary>
/// <param name="logEntryId">A bejegyzés azonosítója</param>
internal LogMessage(string logEntryId)
{
if (string.IsNullOrWhiteSpace(logEntryId))
{
logEntryId = Guid.NewGuid().ToString();
}
m_LogEntryId = logEntryId;
}
/// <summary>
/// <see cref="ILogMessage"/>
/// </summary>
public string LogEntryId
{
get
{
return this.m_LogEntryId;
}
}
/// <summary>
/// <see cref="ILogMessage"/>
/// </summary>
public Events EventType
{
get
{
return this.m_EventType;
}
set
{
this.m_EventType = value;
}
}
/// <summary>
/// <see cref="ILogMessage"/>
/// </summary>
public LogLevel Level
{
get
{
return this.m_Level;
}
set
{
this.m_Level = value;
}
}
/// <summary>
/// <see cref="ILogMessage"/>
/// </summary>
public string SessionId
{
get
{
return this.m_SessionId;
}
set
{
this.m_SessionId = value;
}
}
/// <summary>
/// A felhasználó azonosítója.
/// </summary>
public string UserId
{
get
{
return m_UserId;
}
set
{
m_UserId = value;
}
}
/// <summary>
/// A bejegyzés naplóba lett-e már írva, vagy sem.
/// </summary>
public bool IsLogged
{
get
{
return m_IsLogged;
}
set
{
m_IsLogged = value;
}
}
/// <summary>
/// Az üzenet paraméterei.
/// </summary>
public IDictionary Parameters
{
get
{
return m_Parameters;
}
}
public int? IntezmenyId
{
get
{
return intezmenyid;
}
set
{
this.intezmenyid = value;
}
}
public int? TanevId
{
get
{
return tanevid;
}
set
{
this.tanevid = value;
}
}
/// <summary>
/// Beállítja egy paraméter értékét.
/// </summary>
/// <param name="parameterName">A paraméter típusa</param>
/// <param name="value">A paraméter értéke</param>
public void SetParameter(LogParameter parameterName, object value)
{
this.m_Parameters[parameterName] = value;
}
/// <summary>
/// Lásd <see cref="IEnumerable.GetEnumerator"/>.
/// </summary>
/// <returns>Lásd <see cref="IEnumerable.GetEnumerator"/></returns>
public IEnumerator GetEnumerator()
{
return m_Parameters.GetEnumerator();
}
}
}

139
Framework/Logging/LogParameter.cs Normal file
View file

@ -0,0 +1,139 @@
namespace Kreta.Framework.Logging
{
/// <summary>
/// A naplózás során használható paraméterek
/// </summary>
public enum LogParameter
{
/// <summary>
/// Művelet neve
/// </summary>
OPERATIONNAME = 1,
/// <summary>
/// Verem hívási lánc
/// </summary>
STACKTRACE = 2,
/// <summary>
/// Munkamenet-azonosító
/// </summary>
SESSIONID = 3,
/// <summary>
/// Ügyfél IP-címe
/// </summary>
CLIENTIP = 4,
/// <summary>
/// Felhazsnáló adatbázisbeli azonosítója
/// </summary>
USERID = 5,
/// <summary>
/// Részletek
/// </summary>
DETAILS = 6,
/// <summary>
/// Entitásnév
/// </summary>
ENTITYNAME = 7,
/// <summary>
/// Entitás adatbázisbeli azonosítója
/// </summary>
ENTITYID = 8,
/// <summary>
/// Kivétel neve
/// </summary>
EXCEPTIONNAME = 9,
/// <summary>
/// Kivétel szövege
/// </summary>
EXCEPTIONMESSAGE = 10,
/// <summary>
/// Attribútumnév
/// </summary>
ATTRIBUTENAME = 11,
/// <summary>
/// Kiszolgáló terheltsége
/// </summary>
SERVERLOAD = 12,
/// <summary>
/// Sikeresség
/// </summary>
SUCCESSFUL = 13,
/// <summary>
/// Esemény oka
/// </summary>
REASON = 14,
/// <summary>
/// Felhasználó neve (bejelentkezési neve)
/// </summary>
USERNAME = 15,
/// <summary>
/// SQL parancs szövege
/// </summary>
SQLTEXT = 16,
/// <summary>
/// Szerepkör azonosító
/// </summary>
ROLEID = 17,
/// <summary>
/// Kivétel forrása
/// </summary>
EXCEPTIONSOURCE = 18,
/// <summary>
/// Hibakód
/// </summary>
ERRORCODE = 19,
/// <summary>
/// Funkció azonosító
/// </summary>
FUNCTIONID = 20,
/// <summary>
/// Helyettesített személy adatbázisbeli azonosítója
/// </summary>
SUBSTITUTEMPLOYEEID = 21,
/// <summary>
/// A kérés XML dokumentuma.
/// </summary>
REQUEST_XML = 22,
/// <summary>
/// A kérés XML dokumentuma.
/// </summary>
LOGIN_TYPE = 23,
/// <summary>
/// A kivételt kiváltó UserContext adatai
/// </summary>
CONTEXT_INFO = 24,
/// <summary>
/// Intézmény
/// </summary>
INTEZMENYID = 25,
/// <summary>
/// Tanév
/// </summary>
TANEVID = 26,
}
}

238
Framework/Logging/LogUtil.cs Normal file
View file

@ -0,0 +1,238 @@
using System;
using System.Collections;
using System.Globalization;
using System.Text;
namespace Kreta.Framework.Logging
{
/// <summary>
/// A napló alrendszer konfigjának a felülete.
/// </summary>
public interface ILogConfig
{
/// <summary>
/// A naplózási szint.
/// </summary>
LogLevel LogLevel { get; }
/// <summary>
/// Konzolra való naplózás engedélyezése.
/// </summary>
bool LogToConsole { get; }
/// <summary>
/// A naplózó kiszolgáló neve.
/// </summary>
string ServerName { get; }
/// <summary>
/// Az adatbázisba naplózás adatbázis kapcsolata.
/// </summary>
string ConnectionString { get; }
}
/// <summary>
/// A napló alrendszer segédosztálya.
/// </summary>
public static class LogUtil
{
/// <summary>
/// Konfigurálja a napló alrendszert
/// </summary>
/// <param name="config">A napló alrendszer konfigja</param>
/// <returns>A gyökér naplvezető objektum</returns>
public static ILogWriter ConfigureLogWriters(ILogConfig config)
{
// <<Assembler>>
MulticastLogWriter result = new MulticastLogWriter(config.LogLevel);
if (config.LogToConsole)
{
result.Add(new ConsoleLogWriter());
}
result.Add(new DatabaseLogWriter(config.ConnectionString, config.ServerName));
return result;
}
/// <summary>
/// Megformáz egy napló üzenetet.
/// </summary>
/// <remarks>
/// Elválasztónak újsorjelet használ.
/// </remarks>
/// <param name="message">A megformázandó naplóüzenet</param>
/// <returns>A formázott üzenet</returns>
public static string FormatMessage(ILogMessage message)
{
return FormatMessage(message, Environment.NewLine);
}
/// <summary>
/// Megformáz egy napló üzenetet.
/// </summary>
/// <param name="message">A megformázandó naplóüzenet</param>
/// <param name="separator">A bejegyzés mezőinek elválasztója</param>
/// <returns>A formázott üzenet</returns>
public static string FormatMessage(ILogMessage message, string separator)
{
if (message == null)
{
return string.Empty;
}
StringBuilder builder = new StringBuilder();
builder.Append("TimeStamp: ");
builder.Append(DateTime.Now.ToString(CultureInfo.GetCultureInfo(1038)));
builder.Append(separator);
builder.Append("Level: ");
builder.Append(message.Level);
builder.Append(separator);
builder.Append("Id: ");
builder.Append(message.LogEntryId);
builder.Append(separator);
builder.Append("Event: ");
builder.Append(message.EventType);
if (!string.IsNullOrWhiteSpace(message.SessionId))
{
builder.Append(separator);
builder.Append("SessionId: ");
builder.Append(message.SessionId);
}
if (message.Parameters.Count > 0)
{
foreach (DictionaryEntry entry in message.Parameters)
{
builder.Append(separator);
builder.Append(entry.Key);
builder.Append(": ");
if (entry.Value != null)
{
builder.Append(entry.Value);
}
}
}
return builder.ToString();
}
/// <summary>
/// Tömören megformáz egy napló üzenetet.
/// </summary>
/// <remarks>
/// Elválasztónak '|' jelet használ.
/// </remarks>
/// <param name="message">A megformázandó naplóüzenet</param>
/// <returns>A formázott üzenet</returns>
public static string FormatMessageCompact(ILogMessage message)
{
return FormatMessageCompact(message, " | ");
}
/// <summary>
/// Tömören megformáz egy napló üzenetet.
/// </summary>
/// <param name="message">A megformázandó naplóüzenet</param>
/// <param name="separator">A bejegyzés mezőinek elválasztója</param>
/// <returns>A formázott üzenet</returns>
public static string FormatMessageCompact(ILogMessage message, string separator)
{
if (message == null)
{
return string.Empty;
}
StringBuilder builder = new StringBuilder();
builder.Append(DateTime.Now.ToString(CultureInfo.GetCultureInfo(1038)));
builder.Append(separator);
builder.Append(message.Level.ToString());
builder.Append(separator);
builder.Append(message.LogEntryId);
builder.Append(separator);
builder.Append(message.EventType.ToString());
if (!string.IsNullOrWhiteSpace(message.SessionId))
{
builder.Append(separator);
builder.Append("SessionId: ");
builder.Append(message.SessionId);
}
if (message.Parameters.Count > 0)
{
foreach (DictionaryEntry entry in message.Parameters)
{
builder.AppendLine();
builder.Append(entry.Key);
builder.AppendLine(": ");
if (entry.Value != null)
{
builder.Append(entry.Value);
}
}
}
return builder.ToString();
}
/// <summary>
/// Megformázza a megadott napló üzenet paramétereit.
/// </summary>
/// <remarks>
/// Elválasztónak újsorjelet használ.
/// </remarks>
/// <param name="message">A megformázandó naplóüzenet</param>
/// <returns>A formázott üzenet</returns>
public static string FormatMessageDetails(ILogMessage message)
{
return FormatMessageDetails(message, Environment.NewLine);
}
/// <summary>
/// Megformázza a megadott napló üzenet paramétereit.
/// </summary>
/// <param name="message">A megformázandó naplóüzenet</param>
/// <param name="separator">A bejegyzés mezőinek elválasztója</param>
/// <returns>A formázott üzenet</returns>
public static string FormatMessageDetails(ILogMessage message, string separator)
{
if (message == null)
{
return string.Empty;
}
int count = message.Parameters.Count;
StringBuilder builder = new StringBuilder();
if (count > 0)
{
builder.Append(separator);
}
foreach (DictionaryEntry entry in message.Parameters)
{
builder.Append(entry.Key);
builder.Append(": ");
if (entry.Value != null)
{
builder.Append(entry.Value);
}
count--;
if (count > 0)
{
builder.Append(separator);
}
}
return builder.ToString();
}
}
}

71
Framework/Logging/LogWriterBase.cs Normal file
View file

@ -0,0 +1,71 @@
using System;
namespace Kreta.Framework.Logging
{
/// <summary>
/// A naplóvezetők absztrakt ősosztálya.
/// </summary>
/// <remarks>
/// Az ősosztály felelőssége a naplózás során történt kivételek egységes kezelése, így azzal a
/// leszármazott osztályoknak nem kell foglalkozniuk.
/// </remarks>
public abstract class LogWriterBase : ILogWriter
{
/// <summary>
/// Fizikailag a naplóba ír egy üzenetet.
/// </summary>
/// <param name="message">A naplóba vezetendő üzenet</param>
protected abstract Guid? DoLog(ILogMessage message);
/// <summary>
/// Does the log.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="logId">The log identifier.</param>
/// <returns></returns>
protected abstract void DoLog(ILogMessage message, Guid logId);
/// <summary>
/// Naplóba ír egy naplóbejegyzést.
/// </summary>
/// <param name="message">A naplóbejegyzés</param>
public Guid? Log(ILogMessage message)
{
try
{
return DoLog(message);
}
catch (LogWriterException)
{
throw;
}
catch (Exception exception)
{
throw new LogWriterException(message, string.Format("Failure writing log in class {0}.", GetType().FullName), exception);
}
}
/// <summary>
/// Logs the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="logId">The log identifier.</param>
/// <returns></returns>
/// <exception cref="LogWriterException"></exception>
public void Log(ILogMessage message, Guid logId)
{
try
{
DoLog(message, logId);
}
catch (LogWriterException)
{
throw;
}
catch (Exception exception)
{
throw new LogWriterException(message, string.Format("Failure writing log in class {0}.", GetType().FullName), exception);
}
}
}
}

84
Framework/Logging/LogWriterException.cs Normal file
View file

@ -0,0 +1,84 @@
using System;
using System.Text;
namespace Kreta.Framework.Logging
{
/// <summary>
/// A napló alrendszer kivétele.
/// </summary>
public sealed class LogWriterException : Exception
{
private ILogMessage m_FailedLogMessage;
/// <summary>
/// Az osztály konstruktora.
/// </summary>
/// <param name="failedLogMessage">A sikertelen naplóbejegyzés</param>
public LogWriterException(ILogMessage failedLogMessage)
: this(failedLogMessage, null, null)
{
}
/// <summary>
/// Az osztály konstruktora.
/// </summary>
/// <param name="message">A kivétel üzenete</param>
public LogWriterException(string message)
: this(null, message, null)
{
}
/// <summary>
/// Az osztály konstruktora.
/// </summary>
/// <param name="message">A kivétel üzenete</param>
/// <param name="innerException">A belső kivétel</param>
public LogWriterException(string message, Exception innerException)
: this(null, message, innerException)
{
}
/// <summary>
/// Az osztály konstruktora.
/// </summary>
/// <param name="failedLogMessage">A sikertelen naplóbejegyzés</param>
/// <param name="message">A kivétel üzenete</param>
/// <param name="innerException">A belső kivétel</param>
public LogWriterException(ILogMessage failedLogMessage, string message, Exception innerException)
: base(message, innerException)
{
m_FailedLogMessage = failedLogMessage;
}
/// <summary>
/// A kivétel üzenete.
/// </summary>
public override string Message
{
get
{
if (m_FailedLogMessage == null)
{
return base.Message;
}
StringBuilder builder = new StringBuilder();
builder.AppendLine(base.Message);
builder.AppendLine("Failed message:");
builder.AppendLine(LogUtil.FormatMessage(m_FailedLogMessage, " | "));
return builder.ToString();
}
}
/// <summary>
/// A sikertelen naplóbejegyzés.
/// </summary>
public ILogMessage FailedLogMessage
{
get
{
return m_FailedLogMessage;
}
}
}
}

431
Framework/Logging/Logger.cs Normal file
View file

@ -0,0 +1,431 @@
using System;
using Kreta.Framework.Exceptions;
using Kreta.Framework.Security;
namespace Kreta.Framework.Logging
{
/// <summary>
/// A naplózható eseményeket kivezető osztály.
/// </summary>
/// <remarks>
/// Célja, hogy tipizáltan egy helyre kivezesse az összes naplózandó
/// eseményt. Az osztály felelőssége, hogy a megfelelő naplóüzenetet
/// állítsa össze a naplózó számára.
/// </remarks>
public sealed class Logger
{
// <<Facade>>
/// <summary>
/// Naplózó segédobjektum
/// </summary>
private ILogWriter m_LogWriter;
/// <summary>
/// Az osztály konstruktora.
/// </summary>
/// <param name="logWriter">A naplózó, ahova dolgozik az objektum</param>
public Logger(ILogWriter logWriter)
{
this.m_LogWriter = logWriter ?? throw new ArgumentNullException(nameof(logWriter));
}
/// <summary>
/// A jelenleg használatos naplózó objektum.
/// </summary>
public static Logger Current
{
get
{
return SDAServer.Instance.Logger;
}
}
/// <summary>
/// A naplózó, ahova dolgozik az objektum.
/// </summary>
public ILogWriter LogWriter
{
get
{
return m_LogWriter;
}
}
#region Belső dolgok
/// <summary>
/// Elvégzi egy naplóüzenet naplóba kerülését
/// </summary>
/// <param name="message">A naplózandó naplóüzenet</param>
private Guid? Log(ILogMessage message)
{
if (message == null)
{
return null;
}
var logId = this.m_LogWriter.Log(message);
message.IsLogged = true;
return logId;
}
private static LogMessage CreateLogMessage(Events eventType, LogLevel logLevel)
{
// <<Factory Method>>
return CreateLogMessage(eventType, logLevel, Guid.NewGuid().ToString());
}
private static LogMessage CreateLogMessage(Events eventType, LogLevel logLevel, string entryId)
{
// <<Factory Method>>
LogMessage result = new LogMessage(entryId);
result.EventType = eventType;
result.Level = logLevel;
UserContext usercontext = UserContext.Instance;
if (usercontext != null)
{
result.UserId = usercontext.FelhasznaloId.ToString();
result.SessionId = usercontext.SessionID;
}
else
{
result.UserId = "<unknown>";
}
return result;
}
#endregion
#region Egyéb események
/// <summary>
/// Egyéb esemény történt.
/// </summary>
/// <remarks>Nem szabad használnunk!</remarks>
public void GeneralEvent(LogLevel logLevel, string details)
{
LogMessage message = CreateLogMessage(Events.GENERAL, logLevel);
message.SetParameter(LogParameter.DETAILS, details);
this.Log(message);
}
/// <summary>
/// Tetszőleges log esemény naplózása.
/// </summary>
/// <param name="oEvent">Esemény tipusa</param>
/// <param name="oLogLevel">LogLevel</param>
/// <param name="details">Részletek</param>
public void CustomEvent(Kreta.Framework.Events oEvent, LogLevel oLogLevel, string details)
{
LogMessage message = CreateLogMessage(oEvent, oLogLevel);
message.SetParameter(LogParameter.DETAILS, details);
this.Log(message);
}
/// <summary>
/// Egy Neptun behívás történt.
/// </summary>
public void NeptunConnectorEvent(string actionName, DateTime actionTime, string serverName)
{
LogMessage message = CreateLogMessage(Events.NEPTUN_CONNECTOR_EVENT, LogLevel.INFO);
message.SetParameter(LogParameter.DETAILS,
string.Format(
"A {0} nevű Neptun szerver {1}-kor egy {2} akciót indított.",
serverName,
actionTime,
actionName));
this.Log(message);
}
/// <summary>
/// A kiszolgáló terheltségét lekérdezték.
/// </summary>
/// <param name="serverLoad">A terheltség</param>
public void ServerLoad(double serverLoad)
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_SERVERLOAD, LogLevel.INFO);
message.SetParameter(LogParameter.SERVERLOAD, serverLoad.ToString());
this.Log(message);
}
/// <summary>
/// Hibás FDL szűrő.
/// </summary>
/// <param name="sqlText">A szűrőben definiált SQL töredék.</param>
public void BadFDL(string sqlText)
{
LogMessage message = CreateLogMessage(Events.FDL_BAD_FILTER, LogLevel.WARNING);
message.SetParameter(LogParameter.SQLTEXT, sqlText);
this.Log(message);
}
#endregion
#region Kiszolgáló eseményei
/// <summary>
/// A konfiguráció sikeresen betöltődött.
/// </summary>
public void ConfigurationLoaded()
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_CONFIGLOADED, LogLevel.DEBUG);
this.Log(message);
}
/// <summary>
/// A kiszolgáló elindult.
/// </summary>
public void ServerStarted()
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_SERVERSTART, LogLevel.INFO);
message.SetParameter(LogParameter.DETAILS, string.Format("Machine Name: {0}", Environment.MachineName));
this.Log(message);
}
/// <summary>
/// A kiszolgáló leállt.
/// </summary>
public void ServerStopped()
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_SERVERSTOP, LogLevel.INFO);
System.Diagnostics.StackTrace stacktrace = new System.Diagnostics.StackTrace(); // XXX
message.SetParameter(LogParameter.STACKTRACE, stacktrace.ToString()); // XXX
this.Log(message);
}
/// <summary>
/// A kiszolgáló külső leállítási kérelmet kapott.
/// </summary>
public void ServerStopping()
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_SERVER_STOPPING, LogLevel.INFO);
message.SetParameter(LogParameter.DETAILS, "Külső leállítási kérelem folyamatban.");
this.Log(message);
}
#endregion
#region Munkamenet kezelés eseményei
/// <summary>
/// Az összes munkamenet meg lett szüntetve.
/// </summary>
/// <param name="successful">Sikeres volt-e</param>
public void SessionCleanup(bool successful)
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_SESSIONCLEANUP, LogLevel.INFO);
message.SetParameter(LogParameter.SUCCESSFUL, successful.ToString());
this.Log(message);
}
public void LoginSuccess(LoginInfo info)
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_USER_LOGIN, LogLevel.INFO);
message.SessionId = info.SessionID;
message.SetParameter(LogParameter.USERID, info.FelhasznaloId);
message.SetParameter(LogParameter.USERNAME, info.BelepesiNev);
message.SetParameter(LogParameter.CLIENTIP, info.ClientIP);
message.SetParameter(LogParameter.INTEZMENYID, info.IntezmenyId);
message.SetParameter(LogParameter.TANEVID, info.AktivTanevId);
this.Log(message);
}
/// <summary>
/// A munkamenet meg lett szűntetve.
/// </summary>
/// <param name="sessionId">A munkamenet azonosítója</param>
public void SessionDeleted(string sessionId)
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_SESSIONDELETED, LogLevel.INFO);
message.SessionId = sessionId;
this.Log(message);
}
/// <summary>
/// A munkamenet lejárt és meg lett szűntetve.
/// </summary>
/// <param name="sessionId">A munkamenet azonosítója</param>
public void SessionExpired(string sessionId)
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_SESSIONEXPIRED, LogLevel.INFO);
message.SessionId = sessionId;
this.Log(message);
}
#endregion
#region Kivételkezelés eseményei
#region Kliens
/// <summary>
/// Kliensen történt kivétel
/// </summary>
/// <param name="_details">A kivétel leírása és körülményei</param>
public void ClientExceptionThrown(string _details)
{
LogMessage message = CreateLogMessage(Events.CLIENT_GENERAL, LogLevel.ERROR);
message.SetParameter(LogParameter.DETAILS, _details);
if (UserContext.Instance != null)
{
message.SetParameter(LogParameter.CONTEXT_INFO, UserContext.Instance.ToString());
}
this.Log(message);
}
#endregion
/// <summary>
/// Kivétel történt.
/// </summary>
/// <param name="exception">A naplózandó kivétel</param>
public Guid? ExceptionThrown(FrameworkException exception)
{
if (exception == null || exception.IsLogged)
{
return null;
}
LogMessage message = CreateLogMessage((Events)exception.ClientErrorCode, exception.LogLevel, exception.Id);
message.SetParameter(LogParameter.DETAILS, ExceptionUtil.ExceptionToString(exception));
if (UserContext.Instance != null)
{
message.SetParameter(LogParameter.CONTEXT_INFO, UserContext.Instance.ToString());
}
else
{
if (exception.Data.Contains(LogParameter.SESSIONID))
{
object obj = exception.Data[LogParameter.SESSIONID];
if (obj.GetType() == typeof(string))
{
message.SessionId = (string)obj;
}
}
}
var logId = this.Log(message);
exception.SetLogged();
return logId;
}
/// <summary>
/// Kivétel történt.
/// </summary>
/// <param name="exception">A naplózandó kivétel</param>
public Guid? ExceptionThrown(Exception exception)
{
return ExceptionThrown(exception, null);
}
/// <summary>
/// Kivétel történt.
/// </summary>
/// <param name="exception">A naplózandó kivétel</param>
/// <param name="clientIP">Az ügyfél IP-címe</param>
public Guid? ExceptionThrown(Exception exception, string clientIP)
{
FrameworkException frameworkexception = exception as FrameworkException;
if (frameworkexception != null)
{
return ExceptionThrown(frameworkexception);
}
if (exception != null && !object.Equals(exception.Data["$IsLogged"], true))
{
LogMessage message = CreateLogMessage(Events.SYSTEM_EXCEPTION, LogLevel.ERROR);
message.SetParameter(LogParameter.DETAILS, ExceptionUtil.ExceptionToString(exception));
if (clientIP != null)
{
message.SetParameter(LogParameter.CLIENTIP, clientIP);
}
if (UserContext.Instance != null)
{
message.SetParameter(LogParameter.CONTEXT_INFO, UserContext.Instance.ToString());
}
var logId = this.Log(message);
exception.Data["$IsLogged"] = true;
return logId;
}
return null;
}
#endregion
#region Akciók eseményei
/// <summary>
/// Akció meghívása történt.
/// </summary>
/// <param name="actionName">Az akció neve</param>
public void ActionExecuted(string actionName)
{
LogMessage message = CreateLogMessage(Events.ACTION_EXECUTE, LogLevel.DEBUG);
message.SetParameter(LogParameter.OPERATIONNAME, actionName);
this.Log(message);
}
#endregion
#region Entitások eseményei
/// <summary>
/// Nem sikerült naplóznunk egy entitás történelmét.
/// </summary>
/// <param name="entityId">Az entitás azonosítója</param>
/// <param name="entityName">Az entitás neve</param>
public void SaveEntityHistoryFailed(int entityId, string entityName)
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_ENTITYHISTORYFAILED, LogLevel.ERROR);
message.SetParameter(LogParameter.ENTITYID, entityId);
message.SetParameter(LogParameter.ENTITYNAME, entityName);
this.Log(message);
}
#endregion
#region Adatbáziskezelés eseményei
/// <summary>
/// Ügylet kezdete.
/// </summary>
public void BeginTransaction()
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_BEGINTRANSACTION, LogLevel.INFO);
this.Log(message);
}
/// <summary>
/// Ügylet vége jóváhagyással.
/// </summary>
public void CommitTransaction()
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_COMMITTRANSACTION, LogLevel.INFO);
this.Log(message);
}
/// <summary>
/// Ügylet vége visszagörgetéssel.
/// </summary>
public void RollbackTransaction()
{
LogMessage message = CreateLogMessage(Events.FRAMEWORK_ROLLBACKTRANSACTION, LogLevel.INFO);
this.Log(message);
}
/// <summary>
/// SQL utasítás lett végrehajtva.
/// </summary>
/// <param name="sqlText">Végrehajtandó SQL utasítás</param>
/// <remarks>Sorszurt SQL utasításra célszeru használni.</remarks>
public void SQLExecuted(string sqlText)
{
LogMessage message = CreateLogMessage(Events.SQL_EXECUTED, LogLevel.DEBUG);
message.SetParameter(LogParameter.SQLTEXT, sqlText);
this.Log(message);
}
#endregion
}
}

132
Framework/Logging/MulticastLogWriter.cs Normal file
View file

@ -0,0 +1,132 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Kreta.Framework.Exceptions;
namespace Kreta.Framework.Logging
{
/// <summary>
/// Multicast-oló naplóvezető <see cref="ILogWriter"/> megvalósítás.
/// </summary>
public sealed class MulticastLogWriter : LogWriterBase
{
// <<Composite>>
readonly IList<ILogWriter> m_LogWriters = new List<ILogWriter>();
LogLevel m_LogLevel;
/// <summary>
/// Az osztály alapértelmezett konstruktora.
/// </summary>
public MulticastLogWriter()
: this(LogLevel.INFO)
{
}
/// <summary>
/// Az osztály konstruktora.
/// </summary>
/// <param name="logLevel">Naplózási szint</param>
public MulticastLogWriter(LogLevel logLevel)
{
m_LogLevel = logLevel;
}
/// <summary>
/// Ggyerek naplóvezetőt vesz fel a listába.
/// </summary>
/// <param name="writer">A gyerek naplóvezető</param>
public void Add(ILogWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (m_LogWriters.Contains(writer))
{
throw new InvalidOperationException("The writer is already added.");
}
m_LogWriters.Add(writer);
}
/// <summary>
/// Naplózási szint.
/// </summary>
/// <remarks>
/// Egy üzenet akkor kerül naplózásra, ha a szintje nagyobb, vagy
/// egyenlő, mint ennek a tulajdonságnak az értéke.
/// </remarks>
public LogLevel Level
{
get
{
return m_LogLevel;
}
set
{
m_LogLevel = value;
}
}
/// <summary>
/// A gyerek naplóvezetők listája.
/// </summary>
public IEnumerable<ILogWriter> LogWriters
{
get
{
return m_LogWriters;
}
}
/// <summary>
/// Naplóba vezeti az üzenetet.
/// </summary>
/// <param name="message">A naplóba vezetendő üzenet</param>
protected override Guid? DoLog(ILogMessage message)
{
var logId = Guid.NewGuid();
MultiLog(message, logId);
return logId;
}
protected override void DoLog(ILogMessage message, Guid logId)
{
MultiLog(message, logId);
}
private void MultiLog(ILogMessage message, Guid logId)
{
if (message == null)
{
return;
}
if (message.Level < m_LogLevel)
{
return;
}
try
{
foreach (ILogWriter writer in m_LogWriters.ToArray())
{
writer.Log(message, logId);
}
}
catch (Exception exception)
{
try
{
ConsoleLogWriter.WriteLine("Child logwriter threw an exception:", LogLevel.ERROR);
ConsoleLogWriter.WriteLine(ExceptionUtil.ExceptionToString(exception), LogLevel.ERROR);
}
catch
{
}
}
}
}
}