public void Log(Constants.Level level, string loggerName, string message)
{
ILog log = LogManager.GetLogger(loggerName);
switch (level)
{
case Constants.Level.TRACE:
log.Trace(message);
break;
case Constants.Level.DEBUG:
log.Debug(message);
break;
case Constants.Level.INFO:
log.Info(message);
break;
case Constants.Level.WARN:
log.Warn(message);
break;
case Constants.Level.ERROR:
log.Error(message);
break;
case Constants.Level.FATAL:
log.Fatal(message);
break;
default:
throw new Exception(string.Format("Logger.Log - unknown level={0}", level));
}
}
/// <summary>
/// Parses a string with the name or value of a level.
/// </summary>
/// <param name="levelString"></param>
/// <returns>
/// null if levelString is null.
/// Otherwise, the actual level.
/// </returns>
public static Constants.Level?ParseLevel(string levelString)
{
if (levelString == null)
{
return(null);
}
// See if levelString contains the name of a level. If so, Enum.Parse it.
if (Enum.IsDefined(typeof(Constants.Level), levelString))
{
Constants.Level level = (Constants.Level)Enum.Parse(typeof(Constants.Level), levelString);
return(level);
}
// If levelString contains a number, parse that
int levelInt;
bool isInt = int.TryParse(levelString, out levelInt);
if (isInt)
{
return(IntToLevel(levelInt));
}
throw new Exception(string.Format("LevelUtils.ParseLevel - unknown level {0}", levelString));
}
/// <summary>
/// Returns the highest level
/// as given in Constants.Level enum.
/// </summary>
/// <returns></returns>
public static Constants.Level HighestLevel()
{
Array values = Enum.GetValues(typeof(Constants.Level));
int value = (int)values.GetValue(values.Length - 1);
Constants.Level level = (Constants.Level)Enum.Parse(typeof(Constants.Level), value.ToString());
return(level);
}
/// <summary>
/// Converts a number to a level.
///
/// Each level is associated with a value. If the number is equal to or lower than a level, but higher than the previous level, than
/// that level is used. So if:
///
/// TRACE = 1000,
/// DEBUG = 2000,
/// INFO = 3000,
/// WARN = 4000,
/// ERROR = 5000,
/// FATAL = 6000
///
/// And the number is: 2500, than this method returns INFO.
///
/// If the number is greater than FATAL (highest level), than FATAL is returned.
/// If the number is lower than TRACE, than TRACE is returned.
///
/// This method assumes that the Constants.Level enum is sorted by value!
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public static Constants.Level IntToLevel(int i)
{
Array values = Enum.GetValues(typeof(Constants.Level));
int nbrItems = values.Length;
for (int j = 0; j < nbrItems; j++)
{
int value = (int)values.GetValue(j);
if (value >= i)
{
Constants.Level level = (Constants.Level)Enum.Parse(typeof(Constants.Level), value.ToString());
return(level);
}
}
// No level found. Return the highest level.
return(HighestLevel());
}
/// <summary>
/// Determines the numeric value of a level.
/// If level is a number, returns the number.
/// If level is a predefined level name, returns number corresponding to that level.
/// Otherwise throws exception.
/// </summary>
/// <param name="level"></param>
/// <returns></returns>
public static int LevelNumber(string level)
{
int levelInt;
if (int.TryParse(level, out levelInt))
{
return(levelInt);
}
// See if levelString contains the name of a level. If so, Enum.Parse it and returns its number.
if (Enum.IsDefined(typeof(Constants.Level), level))
{
Constants.Level levelEnum = (Constants.Level)Enum.Parse(typeof(Constants.Level), level);
return((int)levelEnum);
}
throw new Exception(string.Format("LevelUtils.LevelNumber - unknown level {0}", level));
}
public ZDeflateStream(Stream compressed, Constants.Level level = Constants.Level.BestCompression,
Constants.Strategy strategy = Constants.Strategy.DefaultStrategy, int memLevel = 9,
bool useZlibFormat = false, int windowBits = Constants.MaxBufferSize)
{
Constants.RetCode ret;
_compressed = compressed;
_buffer = new byte[1 << 15];
unsafe
{
fixed(ZStream *pZstream = &_zstrm)
{
ret = Zlib.DeflateInit2(pZstream, (int)level, 8, useZlibFormat ? windowBits : -windowBits, memLevel, strategy);
}
}
if (ret != Constants.RetCode.OK)
{
throw Contracts.Except("Could not initialize zstream. Error code: {0}", ret);
}
_zstrm.AvailOut = (uint)_buffer.Length;
}
public LogData(string message, string loggerName, Constants.Level level, int levelInt,
string clientLogMessage, int clientLogLevel, string clientLogLoggerName, string clientLogRequestId,
DateTime logDateUtc, DateTime logDateServerUtc, DateTime logDate, DateTime logDateServer,
string userAgent, string userHostAddress, string logRequestUrl)
{
Message = message;
LoggerName = loggerName;
Level = level;
LevelInt = levelInt;
ClientLogMessage = clientLogMessage;
ClientLogLevel = clientLogLevel;
ClientLogLoggerName = clientLogLoggerName;
ClientLogRequestId = clientLogRequestId;
LogDateUtc = logDateUtc;
LogDateServerUtc = logDateServerUtc;
LogDate = logDate;
LogDateServer = logDateServer;
UserAgent = userAgent;
UserHostAddress = userHostAddress;
LogRequestUrl = logRequestUrl;
}
private ZlibImpl(ArgumentsBase args, bool isDeflate)
{
Contracts.CheckUserArg(args.CompressionLevel == null ||
(0 <= args.CompressionLevel && args.CompressionLevel <= 9),
nameof(args.CompressionLevel), "Must be in range 0 to 9 or null");
Contracts.CheckUserArg(8 <= args.WindowBits && args.WindowBits <= 15, nameof(args.WindowBits), "Must be in range 8 to 15");
Contracts.CheckUserArg(1 <= args.MemoryLevel && args.MemoryLevel <= 9, nameof(args.MemoryLevel), "Must be in range 1 to 9");
Contracts.CheckUserArg(Enum.IsDefined(typeof(Constants.Strategy), args.Strategy), nameof(args.Strategy), "Value was not defined");
if (args.CompressionLevel == null)
{
_level = Constants.Level.DefaultCompression;
}
else
{
_level = (Constants.Level)args.CompressionLevel;
}
Contracts.Assert(Enum.IsDefined(typeof(Constants.Level), _level));
_windowBits = args.WindowBits;
_isDeflate = isDeflate;
_memoryLevel = args.MemoryLevel;
_strategy = args.Strategy;
}
public void Log(Constants.Level level, string loggerName, string message)
{
LogEntries.Add(new LogEntry(level, loggerName, message));
}
public LogEntry(Constants.Level level, string loggerName, string message)
{
Level = level;
LoggerName = loggerName;
Message = message;
}
public void AddDocument(string name, string description, string storageUrl, string userId, Constants.Level level, int levelId)
{
// "level" is either course, module or activity
// "levelId" is either a courseID, a moduleID or an activityID, depending on "level"
var document = new Document
{
Name = name,
Description = description,
UploadTimeStamp = DateTime.Now,
Storage = storageUrl,
ApplicationUserId = userId
};
switch (level)
{
case Constants.Level.Course:
document.CourseId = levelId;
break;
case Constants.Level.Module:
document.ModuleId = levelId;
break;
case Constants.Level.Activity:
document.ActivityId = levelId;
break;
}
db.Documents.Add(document);
db.SaveChanges();
// TODO return something useful -
// for example check if the create worked and then return an LmsResult
}
