public void LogBlockEnd(FunctionId functionId, LogMessage logMessage, int blockId, int delta, CancellationToken cancellationToken)
{
var kvLogMessage = logMessage as KeyValueLogMessage;
if (kvLogMessage == null)
{
return;
}
try
{
// guard us from exception thrown by telemetry
var telemetryEvent = CreateTelemetryEvent(functionId, End);
SetBlockId(telemetryEvent, functionId, blockId);
var durationName = functionId.GetPropertyName(Duration);
telemetryEvent.SetIntProperty(durationName, delta);
var cancellationName = functionId.GetPropertyName(CancellationRequested);
telemetryEvent.SetBoolProperty(cancellationName, cancellationToken.IsCancellationRequested);
_session.PostEvent(telemetryEvent);
}
catch
{
}
}
/// <summary>
/// Processes the specified log message
/// </summary>
/// <param name="message"></param>
protected override void ProcessMessage(LogMessage message)
{
// Call base
base.ProcessMessage(message);
// Transform log type and strip the tag
Imports.OxideNative_LogType logType;
string msg;
switch (message.Type)
{
case LogType.Debug:
logType = Imports.OxideNative_LogType.Debug;
msg = message.Message.Replace(" [Debug]", ":");
break;
case LogType.Info:
logType = Imports.OxideNative_LogType.Info;
msg = message.Message.Replace(" [Info]", ":");
break;
case LogType.Warning:
logType = Imports.OxideNative_LogType.Warning;
msg = message.Message.Replace(" [Warning]", ":");
break;
case LogType.Error:
logType = Imports.OxideNative_LogType.Error;
msg = message.Message.Replace(" [Error]", ":");
break;
default:
return;
}
// Forward it to native
Imports.OxideNative_WriteLog(logType, msg);
}
/// <summary>
/// Fail safe UserLog gate to write internal exception without main logging context, but with max guarantee of regestering
/// synchronous
/// </summary>
public void LogFailSafe(LogMessage message) {
if (null == message) {
return;
}
if (string.IsNullOrEmpty(message.Name)) {
message.Name = "FAILSAFE";
}
try {
StreamWriter wr = null;
for (var i = 0; i < 100; i++) {
try {
wr = new StreamWriter(Path.Combine(EnvironmentInfo.RootDirectory, "failsafelog" + i + ".txt"), true, Encoding.UTF8);
break;
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception) {}
// ReSharper restore EmptyGeneralCatchClause
}
if (null == wr) {
var tmpfile = Path.GetTempFileName() + ".failsafelog." +
DateTime.Now.ToString("yyyy-MM-dd-hh-mm-ss", CultureInfo.InvariantCulture) + ".txt";
wr = new StreamWriter(tmpfile, true, Encoding.UTF8);
}
using (wr) {
wr.WriteLine(message.ToString());
wr.Flush();
}
}
catch (Exception ex) {
throw new LogException("even safe mode fails to be executed", ex);
}
}
public static void Log(string input)
{
var endpoint = GlobalHost.ConnectionManager.GetConnectionContext<ExecuteEndPoint>().Connection;
var logMessage = new LogMessage(input);
endpoint.Broadcast(logMessage);
}
private static void RegisterDiagnostics(ContainerBuilder builder)
{
builder.Register(
c =>
{
var loggers = c.Resolve<IEnumerable<ILogger>>();
Action<LevelToLog, string> action = (p, s) =>
{
var msg = new LogMessage(p, s);
foreach (var logger in loggers)
{
try
{
logger.Log(msg);
}
catch (NLogRuntimeException)
{
// Ignore it and move on to the next logger.
}
}
};
return new SystemDiagnostics(action, null);
})
.As<SystemDiagnostics>()
.SingleInstance();
}
/// <summary>
/// Возвращет форматированный текст из представления сообщения <see cref="LogMessage"/>
/// </summary>
/// <param name="message">Представление сообщения <see cref="LogMessage"/></param>
/// <returns>Форматированная строка сообщения</returns>
protected virtual string GetFormatted(LogMessage message) {
string text;
if (!string.IsNullOrEmpty(CustomFormat)) {
text = Regex.Replace(CustomFormat, @"\$\{(\w+)\}", m =>
{
var propName = m.Groups[1].Value;
var prop = message.GetType().GetProperty(propName);
if (null != prop) {
var val = prop.GetValue(message, null);
if (null == val) {
return "";
}
if (val is DateTime) {
return ((DateTime) val).ToString("yyyy-MM-dd HH:mm:ss");
}
return val.ToString();
}
return "";
});
}
else {
text = message.ToString();
}
return text;
}
public ErrLog(string msg, string location, string state, LogMessage originalMessage)
{
ErrorMessage = msg;
ParserState = state;
ErrorLocation = location;
LogData = originalMessage;
}
public void Log(LogMessage message)
{
lock (_lock)
{
_wrappedLog.Log(message);
}
}
public override void Log ( LogMessage message )
{
Colorize( message.MessageType );
GetWriter( message.MessageType ).WriteLine("{2}", message.DateTime, message.ThreadId, message.MessageText );
Console.ResetColor();
}
/// <summary>
/// Creates a log message from the specified arguments
/// </summary>
/// <param name="type"></param>
/// <param name="format"></param>
/// <param name="args"></param>
/// <returns></returns>
protected LogMessage CreateLogMessage(LogType type, string format, object[] args)
{
LogMessage msg = new LogMessage { Type = type, Message =
$"{DateTime.Now.ToShortTimeString()} [{type}] {format}"
};
if (args.Length != 0) msg.Message = string.Format(msg.Message, args);
return msg;
}
/// <summary>
/// Writes a message to this logger
/// </summary>
/// <param name="msg"></param>
internal virtual void Write(LogMessage msg)
{
// If we're set to process immediately, do so, otherwise enqueue
if (processmessagesimmediately)
ProcessMessage(msg);
else
messagequeue.Enqueue(msg);
}
/// <summary>
///
/// </summary>
/// <param name="logmessage"></param>
public override void Write(LogMessage logmessage)
{
base.Write(logmessage);
if (logmessage.Level >= this.Level){
Messages.Add(logmessage);
}
}
public void saveLog(LogLevel logLevel, string message)
{
LogMessage n = new LogMessage (logLevel, message);
if (_messages.Count >= max) {
_messages.RemoveAt (0);
}
_messages.Add (n);
}
/// <summary>
/// Record the log message to the console.
/// </summary>
/// <param name="logMessage">The log message object to record</param>
protected internal override void Log(LogMessage logMessage)
{
if (logMessage == null) return;
DateTime time = DateTime.FromBinary(logMessage.Time);
String level = Enum.GetName(typeof(LogLevel), logMessage.Level);
Console.WriteLine(OutputFormat, time, level, logMessage.Tag, logMessage.Message);
}
public static void Display(LogMessage message)
{
writeTimePrefix();
writeTypePrefix(message.LogType, message.BGColor, message.FGColor);
for (int i = 0; i < 40 - message.Message.Length; i++)
message.Message += " ";
Console.WriteLine(message.Message);
}
/// <summary>
/// </summary>
/// <param name="message"> </param>
protected override void InternalWrite(LogMessage message) {
var resolvedFileName = GetResolvedFileName(message);
var text = "";
text = GetText(message);
using (var sw = new StreamWriter(resolvedFileName, true, Encoding.UTF8)) {
sw.WriteLine(text);
sw.Flush();
}
}
/// <summary>
/// ¬нутренн¤¤ операци¤ записи в лог
/// </summary>
/// <param name="message">“екст сообщени¤ в формате <see cref="LogMessage"/></param>
protected override void InternalWrite(LogMessage message) {
if (null == _writer) {
return;
}
var text = GetText(message);
_writer.WriteLine(text);
_writer.Flush();
}
static void WriteLine(LogMessage message, ConsoleColor color)
{
Console.ForegroundColor = color;
Console.WriteLine(message.Message);
if (message.Exception != null)
Console.WriteLine(message.Exception);
Console.ResetColor();
}
bool Filter(LogMessage m) {
if ((m.Type == LogType.Debug && showDebug)
|| (m.Type == LogType.Error && showErrors)
|| (m.Type == LogType.Metrics && showMetrics)
|| (m.Type == LogType.Warning && showWarnings))
return true;
return false;
}
public void CanParseDelayedMessage()
{
var logFile = @"00:26 [2013-12-24 00:15] < Nightmare Moon> BEEP BEEP MOTHERFUCKERS!!!";
var expected = new LogMessage(new DateTime(2013, 12, 24, 0, 15, 0), "Nightmare Moon", "BEEP BEEP MOTHERFUCKERS!!!");
var logMessage = new LogParser().Parse(logFile).Single();
Assert.Equal(expected, logMessage);
}
/// <summary>
/// Регистрирует сообщения
/// </summary>
/// <param name="message"></param>
public LogMessage Register(LogMessage message){
if (_config.ContainsKey(message.Code)){
return ProcessConfigured(message,_config[message.Code]);
}
else{
_log.Add(message);
return message;
}
}
public override void Log ( LogMessage message )
{
Colorize( message.MessageType );
GetWriter( message.MessageType ).WriteLine("[{0:HH:mm:ss}] {1}> : {2}", message.DateTime, message.ThreadId, message.MessageText );
//GetWriter( message.MessageType ).WriteLine("{1,2}| {2}", message.DateTime, message.ThreadId, message.MessageText );
Console.ResetColor();
}
public LogException(LogMessage msg) {
Msg = msg;
try {
Data["Severity"] = msg.Severity;
// Disabled because members of the Data dictionary must be serializable,
// but msg.Context might not be. We could convert to string, but is it
// worth the performance cost? Loyc code isn't really using Data anyway.
//Data["Context"] = msg.Context;
} catch { }
}
public void LogBlockEnd(FunctionId functionId, LogMessage logMessage, int uniquePairId, int delta, CancellationToken cancellationToken)
{
if (!_pendingActivities.TryRemove(uniquePairId, out var activity))
{
Contract.Requires(false, "when can this happen?");
return;
}
activity.Dispose();
}
protected string StringifyLogMessage(LogMessage logMessage)
{
var sb = new StringBuilder();
sb.AppendFormat("{0}: {1}", logMessage.LogType, logMessage.Message).AppendLine();
if (logMessage.Uri != null)
sb.AppendFormat("\tUri: ").Append(logMessage.Uri).AppendLine();
if (logMessage.Exception != null)
sb.AppendFormat("\tException: ").Append(logMessage.Exception).AppendLine();
return sb.ToString();
}
public void ItFormatsTimestampsAsExpected()
{
var logMessage = new LogMessage
{
Message = "Hello, world!",
};
var jsonMessage = logMessage.ToString();
var dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonMessage);
var regex = new Regex(@"\d+\.\d{9}");
StringAssert.Matches(dictionary["timestamp"], regex);
}
public void Construct(ILogger logger, FunctionId functionId, LogMessage logMessage, int blockId, CancellationToken cancellationToken)
{
this.logger = logger;
this.functionId = functionId;
this.logMessage = logMessage;
this.tick = Environment.TickCount;
this.blockId = blockId;
this.cancellationToken = cancellationToken;
logger.LogBlockStart(functionId, logMessage, blockId, cancellationToken);
}
public void Publish(LogMessage logMessage)
{
if (cleanOutput)
{
Console.WriteLine(logMessage.Text);
}
else
{
Console.WriteLine(_loggerFormatter.ApplyFormat(logMessage));
}
}
public void AddMessage(LogMessage message) {
if (InvokeRequired) {
Invoke(new Action(delegate { AddMessage(message); }));
return;
}
if (Filter(message)) {
list.Items.Add(MakeItem(message));
ScrollToEnd();
}
}
public void LogBlockEnd(FunctionId functionId, LogMessage logMessage, int uniquePairId, int delta, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
RoslynEventSource.Instance.BlockCanceled(functionId, delta, uniquePairId);
}
else
{
RoslynEventSource.Instance.BlockStop(functionId, delta, uniquePairId);
}
}
/// <summary>
/// Selects the given <paramref name="message"/>.
/// </summary>
/// <param name="message">The <see cref="LogMessage"/> o select</param>
public bool SelectLogMessage(LogMessage message)
{
// There is no select message support for the logger tree.
return(true);
}
private Task Log(LogMessage message)
{
Debug.Log(message.Message);
return(Task.CompletedTask);
}
public virtual void AfterLog(LogMessage logMessage)
{
}
private Task LogFromBot(LogMessage msg)
{
Log.Info(msg.ToString());
return(Task.CompletedTask);
}
private Task OnLogAsync(LogMessage msg) => PrettyConsole.LogAsync(msg.Severity, msg.Source, msg.Message);
public static void Log(LogMessage message)
{
Action?.Invoke($"State: {message.IsSuccess}, Message: {message.Message}");
}
/// <summary>
/// Processes the specified message
/// </summary>
/// <param name="message"></param>
protected virtual void ProcessMessage(LogMessage message)
{
}
private Task LogAsync(LogMessage logMessage)
{
Console.WriteLine(logMessage.Message);
return(Task.CompletedTask);
}
protected void Log(string msg)
{
Log(LogMessage.Info(msg));
}
private Task LogAsync(LogMessage Log)
{
Console.WriteLine(Log.ToString());
return(Task.CompletedTask);
}
private async Task Log(LogMessage msg)
{
Console.WriteLine(msg.Message);
}
private Task Log(LogMessage msg)
{
Console.WriteLine(msg.ToString());
return(Task.CompletedTask);
}
public async Task Log(LogMessage message)
{
await objDb.Log(message);
}
public abstract Task <int> Write(LogMessage message);
public void GetWarningMessage_NullMessage_DoesNotThrowException(string message)
{
LogMessage log = new LogMessage(message);
Assert.DoesNotThrow(() => log.GetWarningMessage());
}
public LogMessageEventArgs(LogMessage logMessage)
{
LogMessage = logMessage;
}
public override async Task LogAsync(LogMessage logMessage)
{
Console.WriteLine(logMessage.ToString());
await Task.CompletedTask;
}
private async Task LogAsync(LogMessage logMessage)
{
await _logService.LogAsync(logMessage);
}
private static Task AnnouncerLog(LogMessage msg)
{
Console.WriteLine($"{msg} [Announcer]");
return(Task.CompletedTask);
}
public ForwardingLogger(string categoryName, LogMessage logAction)
{
_categoryName = categoryName;
_logAction = logAction;
}
/// <summary>
/// Selects the given <paramref name="message"/>.
/// </summary>
/// <param name="message">The <see cref="LogMessage"/> o select</param>
/// <returns><c>True</c> if the given <paramref name="message"/> was selected successfully, otherwise <c>false</c>.</returns>
public bool SelectLogMessage(LogMessage message)
{
// Nothing to do here.
return(true);
}
public void Run()
{
Task.Run(async() => {
LogMessage LogDownstreamText(LogEventLevel level, string text = null) => LogMessage.Downstream(level, Id, _downstreamClient.Endpoint.Address, text);
LogMessage LogDownstreamException(Exception exception) => LogMessage.Downstream(exception, Id, _downstreamClient.Endpoint.Address);
LogMessage LogUpstreamText(LogEventLevel level, string text = null) => LogMessage.Upstream(level, Id, _upstreamServer.Endpoint.Address, text);
LogMessage LogUpstreamException(Exception exception) => LogMessage.Upstream(exception, Id, _upstreamServer.Endpoint.Address);
LogMessage LogForwardProxyText(LogEventLevel level, string text = null) => LogMessage.ForwardProxy(level, Id, _upstreamServer.Endpoint.Address, text);
LogMessage LogForwardProxyException(Exception exception) => LogMessage.ForwardProxy(exception, Id, _upstreamServer.Endpoint.Address);
RequestLine requestLine;
IEnumerable <Header> headers;
HostHeader hostHeader;
try {
(GetRequestLineResult result, RequestLine requestLine)getRequestLineResult = _downstreamClient.GetRequestLine();
switch (getRequestLineResult.result)
{
case GetRequestLineResult.Success:
requestLine = getRequestLineResult.requestLine;
break;
case GetRequestLineResult.InvalidRequestLine:
LogDownstreamText(LogEventLevel.Error, "Invalid request line").Write();
goto close;
default:
throw new ArgumentOutOfRangeException();
}
(GetHeadersResult result, IEnumerable <Header> headers)getHeadersResult = _downstreamClient.GetHeaders();
getHeadersResult.headers = getHeadersResult.headers ?? Enumerable.Empty <Header>();
switch (getHeadersResult.result)
{
case GetHeadersResult.Success:
headers = getHeadersResult.headers.ToImmutableArray();
break;
case GetHeadersResult.InvalidHeader:
LogDownstreamText(LogEventLevel.Error, "Invalid header").Write();
goto close;
default:
throw new ArgumentOutOfRangeException();
}
hostHeader = HostHeader.Parse(getHeadersResult.headers.FirstOrDefault(x => x.Name.Equals("Host", StringComparison.OrdinalIgnoreCase)));
LogDownstreamText(LogEventLevel.Information).RightArrow(true).Text($"{getRequestLineResult.requestLine}{(hostHeader != null ? $", {hostHeader}" : "")}").Write();
}
catch (Exception exception) {
LogDownstreamException(exception).Write();
goto close;
}
bool isTunnel = requestLine.Method == "CONNECT";
string upstreamHost;
int upstreamPort;
if (requestLine.ParsedRequestUri.IsAbsoluteUri && _validAbsoluteUriSchemes.Contains(requestLine.ParsedRequestUri.Scheme, StringComparer.OrdinalIgnoreCase))
{
upstreamHost = requestLine.ParsedRequestUri.Host;
upstreamPort = requestLine.ParsedRequestUri.Port;
}
else if (hostHeader != null)
{
upstreamHost = hostHeader.Host;
upstreamPort = hostHeader.Port ?? (isTunnel ? 443 : 80);
}
else
{
LogDownstreamText(LogEventLevel.Error, "Missing Host header").Write();
goto close;
}
if (_disallowedHosts.Any(x => x.Contains(upstreamHost) == ContainsResult.Yes))
{
LogDownstreamText(LogEventLevel.Error, $"Host '{upstreamHost}' is disallowed").Write();
goto close;
}
ConfigModel.ForwardProxiesModel.ForwardProxyModel forwardProxy = isTunnel ? _forwardProxyHttps : _forwardProxyHttp;
async Task <bool> ConnectToUpstreamServerAsync()
{
_upstreamServer?.Close();
var upstreamServer = new TcpClient();
try {
if (forwardProxy != null && _noProxyHosts.All(x => x.Contains(upstreamHost) != ContainsResult.Yes))
{
await upstreamServer.ConnectAsync(forwardProxy.Host, forwardProxy.Port);
}
else
{
forwardProxy = null;
await upstreamServer.ConnectAsync(upstreamHost, upstreamPort);
}
}
catch (Exception exception) {
LogDownstreamException(exception).Write();
return(false);
}
_upstreamServer = _httpClientFactory.Create(upstreamServer);
return(true);
}
if (!await ConnectToUpstreamServerAsync())
{
goto close;
}
if (isTunnel)
{
var responseStatusLine = new ResponseStatusLine(requestLine.HttpVersion, 200);
_downstreamClient.WriteResponseStatusLine(responseStatusLine);
if (_configService.Config.Options.SendProxyAgentHeader)
{
_downstreamClient.WriteHeader("Proxy-Agent", typeof(Program).Namespace);
}
_downstreamClient.WriteNewLine();
_downstreamClient.Flush();
LogDownstreamText(LogEventLevel.Information).LeftArrow(true).Text(responseStatusLine.ToString()).Write();
if (forwardProxy != null)
{
LogForwardProxyText(LogEventLevel.Information).LeftArrow(true).Text($"{requestLine}{(hostHeader != null ? $", {hostHeader}" : "")}").Write();
_upstreamServer.WriteRequestLine(requestLine);
_upstreamServer.WriteHeaders(hostHeader);
_upstreamServer.WriteNewLine();
(GetResponseStatusLineResult result, ResponseStatusLine responseStatusLine)responseStatusLineResult = _upstreamServer.GetResponseStatusLine();
switch (responseStatusLineResult.result)
{
case GetResponseStatusLineResult.Success:
LogForwardProxyText(LogEventLevel.Information).RightArrow(true).Text(responseStatusLineResult.responseStatusLine.ToString()).Write();
break;
case GetResponseStatusLineResult.InvalidResponseStatusLine:
LogForwardProxyText(LogEventLevel.Error, "Invalid response status line").Write();
break;
default:
throw new ArgumentOutOfRangeException();
}
_upstreamServer.GetHeaders();
}
}
else
{
void WriteUpstreamServerRequest(params Header[] additionalHeaders)
{
_upstreamServer.WriteRequestLine(requestLine);
_upstreamServer.WriteHeaders(headers);
if (_configService.Config.Options.SendProxyAgentHeader)
{
_upstreamServer.WriteHeaders(Header.Parse($"Proxy-Agent: {typeof(Program).Namespace}"));
}
_upstreamServer.WriteHeaders(additionalHeaders);
_upstreamServer.WriteNewLine();
_upstreamServer.Flush();
}
WriteUpstreamServerRequest();
if (forwardProxy != null && forwardProxy.Authentication.Basic.Enabled)
{
(GetResponseStatusLineResult result, ResponseStatusLine responseStatusLine)getResponseStatusLineResult = _upstreamServer.GetResponseStatusLine();
switch (getResponseStatusLineResult.result)
{
case GetResponseStatusLineResult.Success:
break;
case GetResponseStatusLineResult.InvalidResponseStatusLine:
LogUpstreamText(LogEventLevel.Error, "Invalid response line");
goto close;
default:
throw new ArgumentOutOfRangeException();
}
if (getResponseStatusLineResult.responseStatusLine.StatusCode == 407)
{
(GetHeadersResult result, IEnumerable <Header> headers)getHeadersResult = _upstreamServer.GetHeaders();
switch (getHeadersResult.result)
{
case GetHeadersResult.Success:
break;
case GetHeadersResult.InvalidHeader:
LogUpstreamText(LogEventLevel.Error, "Invalid header").Write();
goto close;
default:
throw new ArgumentOutOfRangeException();
}
LogForwardProxyText(LogEventLevel.Warning).RightArrow(true).Text(getResponseStatusLineResult.responseStatusLine.ToString()).Write();
if (!await ConnectToUpstreamServerAsync())
{
goto close;
}
(GetCredentialsResult result, string username, string clearTextPassword)getCredentialsResult = _credentialService.GetCredentials();
string base64Credential = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{getCredentialsResult.username}:{getCredentialsResult.clearTextPassword}"));
LogForwardProxyText(LogEventLevel.Warning).LeftArrow(true).Text("Proxy authorization").Write();
WriteUpstreamServerRequest(new Header("Proxy-Authorization", $"Basic {base64Credential}"));
}
else
{
_downstreamClient.WriteResponseStatusLine(getResponseStatusLineResult.responseStatusLine);
}
}
}
var manualResetEvent = new ManualResetEventSlim();
#pragma warning disable 4014
Task.Run(() =>
#pragma warning restore 4014
{
try {
while (true)
{
ArraySegment <byte> arraySegment = _downstreamClient.Read();
if (arraySegment.Count == 0)
{
break;
}
_upstreamServer.Write(arraySegment);
_upstreamServer.Flush();
LogDownstreamText(LogEventLevel.Verbose)
.RightArrow(true)
.Text($"{arraySegment.Count} byte{(arraySegment.Count == 1 ? "" : "s")}")
.RightArrow(true)
.UpstreamIdentifier(Id)
.Space()
.BracketedIpAddress(_upstreamServer.Endpoint.Address)
.Write();
}
}
catch (Exception exception) {
LogDownstreamException(exception).Write();
}
finally {
manualResetEvent.Set();
}
});
#pragma warning disable 4014
Task.Run(() =>
#pragma warning restore 4014
{
try {
while (true)
{
ArraySegment <byte> arraySegment = _upstreamServer.Read();
if (arraySegment.Count == 0)
{
break;
}
_downstreamClient.Write(arraySegment);
_downstreamClient.Flush();
(forwardProxy != null ? LogForwardProxyText(LogEventLevel.Verbose) : LogUpstreamText(LogEventLevel.Verbose))
.RightArrow(true)
.Text($"{arraySegment.Count} byte{(arraySegment.Count == 1 ? "" : "s")}")
.RightArrow(true)
.DownstreamIdentifier(Id)
.Space()
.BracketedIpAddress(_downstreamClient.Endpoint.Address)
.Write();
}
}
catch (Exception exception) {
(forwardProxy != null ? LogForwardProxyException(exception) : LogUpstreamException(exception)).Write();
}
finally {
manualResetEvent.Set();
}
});
manualResetEvent.Wait();
close:
CloseConnections();
LogDownstreamText(LogEventLevel.Information, "Connection closed").Write();
_closedByClient.OnNext(Unit.Default);
});
}
/// <summary>
/// 初始化Ip格式器
/// </summary>
/// <param name="message">日志消息</param>
public IpFormatter(LogMessage message)
: base(message)
{
}
private Task CommandsOnLog(LogMessage logMessage)
{
return(HandleErrorAsync(logMessage));
}
private void AddLogEntries(List <LogEntry> entries, bool bypassClearingLog = false)
{
if (!bypassClearingLog && _isClearingLog)
{
return;
}
_dispatcherService.BeginInvoke(() =>
{
var filteredLogEntries = new List <LogEntry>();
var typeNames = TypeNames;
var requireSorting = false;
lock (_lock)
{
using (SuspendChangeNotifications())
{
using (_logEntries.SuspendChangeNotifications())
{
foreach (var entry in entries)
{
_logEntries.Add(entry);
if (IsValidLogEntry(entry))
{
filteredLogEntries.Add(entry);
}
var targetTypeName = entry.Log.TargetType.Name;
if (!typeNames.Contains(targetTypeName))
{
try
{
typeNames.Add(targetTypeName);
requireSorting = true;
}
catch (Exception)
{
// we don't have time for this, let it go...
}
}
}
}
}
}
UpdateEntriesCount(entries);
if (requireSorting)
{
lock (_lock)
{
using (typeNames.SuspendChangeNotifications())
{
typeNames.Sort();
typeNames.Remove(DefaultComboBoxItem);
typeNames.Insert(0, DefaultComboBoxItem);
}
}
}
LogMessage.SafeInvoke(this, new LogEntryEventArgs(entries, filteredLogEntries));
});
}
private async Task client_log(LogMessage message)
{
Console.WriteLine($"{DateTime.Now} at {message.Source} {message.Message}");
}
public void Publish(LogMessage logMessage)
{
Console.WriteLine(DefaultLoggerFormatter.ApplyFormat(logMessage));
}
public List <RequiredDocuments> GetAllRequiredDocumentsByTravelId(string travelRequestId, int badgeNumber)
{
List <RequiredDocuments> result = new List <RequiredDocuments>();
try
{
using (dbConn = ConnectionFactory.GetOpenDefaultConnection())
{
for (int i = 1; i < 6; i++)
{
result.Add(new RequiredDocuments()
{
DocumentNumber = i,
TravelRequestId = travelRequestId,
FileName = string.Empty,
DocumentName = string.Empty,
Visible = (i == 1 || i == 2) ? true : false
});
}
string query = string.Format("Select CASHADVANCE from TRAVELREQUEST_ESTIMATEDEXPENSE where TRAVELREQUESTID = {0} AND CASHADVANCE > 0 ", travelRequestId);
OracleCommand command = new OracleCommand(query, (OracleConnection)dbConn);
command.CommandText = query;
DbDataReader dataReader = command.ExecuteReader();
if (dataReader != null)
{
while (dataReader.Read())
{
result.FirstOrDefault(p => p.DocumentNumber == 3).Visible = true;
}
}
dataReader.Close();
command.Dispose();
string query2 = string.Format("Select TOTALESTIMATEDREGISTRATION from TRAVELREQUEST_ESTIMATEDEXPENSE where TRAVELREQUESTID = {0} AND TOTALESTIMATEDREGISTRATION > 0 ", travelRequestId);
OracleCommand command2 = new OracleCommand(query2, (OracleConnection)dbConn);
command2.CommandText = query2;
DbDataReader dataReader2 = command2.ExecuteReader();
if (dataReader2 != null)
{
while (dataReader2.Read())
{
result.FirstOrDefault(p => p.DocumentNumber == 4).Visible = true;
}
}
dataReader2.Close();
command2.Dispose();
string query1 = string.Format("Select TRAVELREQUESTID, FILENAME, REQUIREDORDER from Travel_Uploads where TRAVELREQUESTID = {0} and Requiredorder is not null ", travelRequestId);
OracleCommand command1 = new OracleCommand(query1, (OracleConnection)dbConn);
command1.CommandText = query1;
DbDataReader dataReader1 = command1.ExecuteReader();
if (dataReader1 != null)
{
while (dataReader1.Read())
{
result.FirstOrDefault(p1 => p1.DocumentNumber == Convert.ToInt32(dataReader1["REQUIREDORDER"])).FileName = dataReader1["FILENAME"].ToString();
}
}
dataReader1.Close();
command1.Dispose();
dbConn.Close();
dbConn.Dispose();
return(result);
}
}
catch (Exception ex)
{
LogMessage.Log("DocumentRepository : GetAllDocumentsByTravelId - returns required documents" + ex.Message);
throw new Exception("Couldn't retrieve all the documents by travel id");
}
}
private void Log(string message)
{
Log(LogMessage.Info(message));
}
public ForwardingLoggerProvider(LogMessage logAction)
{
_logAction = logAction;
}
