public ForEachBlockTranslator(
CSharpName supportRefName,
CSharpName envClassName,
CSharpName envRefName,
CSharpName outerClassName,
CSharpName outerRefName,
VBScriptNameRewriter nameRewriter,
TempValueNameGenerator tempNameGenerator,
ITranslateIndividualStatements statementTranslator,
ITranslateValueSettingsStatements valueSettingStatementTranslator,
ILogInformation logger)
: base(supportRefName, envClassName, envRefName, outerClassName, outerRefName, nameRewriter, tempNameGenerator, statementTranslator, valueSettingStatementTranslator, logger)
{
if (statementTranslator == null)
{
throw new ArgumentNullException("statementTranslator");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_statementTranslator = statementTranslator;
_logger = logger;
}
protected override void ProtectedLog(ILogInformation info)
{
Debug.WriteLine(info.ToString());
ILog _log = LogManager.GetLogger(_repositoryName, _loggerName);
if (_log != null)
{
var level = Map(info.Type);
if (_log.Logger.IsEnabledFor(level))
{
LoggingEventData logData = new LoggingEventData();
logData.Message = info.Message;
logData.Level = level;
//copy info into log4net world to log.
logData.Properties = new PropertiesDictionary();
logData.Properties["UserName"] = info.UserName;
logData.Properties["Origin"] = info.Origin;
logData.Properties["LogType"] = info.Type.ToString();
logData.Properties["Message"] = info.Message;
logData.Properties["Category"] = info.Category;
logData.Properties["ActivityID"] = info.ActivityID;
logData.Properties["Data"] = info.DataSerialized; // (info.Data != null ? JsonConvert.SerializeObject(info.Data, _jsonSettings) : null);
logData.Properties["CreationDate"] = DateTime.UtcNow;
if (info.Exception != null)
{
logData.Properties["Exception"] = info.Exception.ToString();
}
_log.Logger.Log(new LoggingEvent(logData));
}
}
}
public void Log(ILogInformation info)
{
if (!EventLog.SourceExists(Logzy.Configuration.EventSource))
{
EventLog.CreateEventSource(Logzy.Configuration.EventSource, Logzy.Configuration.EventLog);
}
EventLogEntryType type;
switch (info.Level)
{
case LogzyLevel.Debug:
case LogzyLevel.Info:
type = EventLogEntryType.Information;
break;
case LogzyLevel.Error:
case LogzyLevel.Warn:
type = EventLogEntryType.Error;
break;
default:
type = EventLogEntryType.Information;
break;
}
EventLog.WriteEntry(Logzy.Configuration.EventSource, info.ToString(), type);
}
public CSharpCommentMakingLogger(ILogInformation logger)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_logger = logger;
}
public virtual void Log(ILogInformation info)
{
Debug.WriteLine(info.ToString());
if (IsEnabledFor(info.Type))
{
ProtectedLog(info);
}
}
public OuterScopeBlockTranslator(
CSharpName startNamespace,
CSharpName startClassName,
CSharpName startMethodName,
CSharpName runtimeDateLiteralValidatorClassName,
CSharpName supportRefName,
CSharpName envClassName,
CSharpName envRefName,
CSharpName outerClassName,
CSharpName outerRefName,
VBScriptNameRewriter nameRewriter,
TempValueNameGenerator tempNameGenerator,
ITranslateIndividualStatements statementTranslator,
ITranslateValueSettingsStatements valueSettingStatementTranslator,
NonNullImmutableList <NameToken> externalDependencies,
OutputTypeOptions outputType,
ILogInformation logger)
: base(supportRefName, envClassName, envRefName, outerClassName, outerRefName, nameRewriter, tempNameGenerator, statementTranslator, valueSettingStatementTranslator, logger)
{
if (startNamespace == null)
{
throw new ArgumentNullException("startNamespace");
}
if (startClassName == null)
{
throw new ArgumentNullException("startClassName");
}
if (startMethodName == null)
{
throw new ArgumentNullException("startMethodName");
}
if (runtimeDateLiteralValidatorClassName == null)
{
throw new ArgumentNullException("runtimeDateLiteralValidatorClassName");
}
if (externalDependencies == null)
{
throw new ArgumentNullException("externalDependencies");
}
if (!Enum.IsDefined(typeof(OutputTypeOptions), outputType))
{
throw new ArgumentOutOfRangeException("outputType");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_startNamespace = startNamespace;
_startClassName = startClassName;
_startMethodName = startMethodName;
_runtimeDateLiteralValidatorClassName = runtimeDateLiteralValidatorClassName;
_externalDependencies = externalDependencies;
_outputType = outputType;
_logger = logger;
}
public DurationLogger(ILogger logger, ILogInformation logInformation, TimeSpan?minimumDuration = null)
{
_logger = logger;
_logInformation = logInformation;
_stopwatch = new Stopwatch();
_startDate = DateTime.UtcNow;
if (minimumDuration.HasValue && minimumDuration.Value > TimeSpan.Zero)
{
_minDuration = minimumDuration.Value;
}
_stopwatch.Start();
}
public ClassBlockTranslator(
CSharpName supportRefName,
CSharpName envClassName,
CSharpName envRefName,
CSharpName outerClassName,
CSharpName outerRefName,
VBScriptNameRewriter nameRewriter,
TempValueNameGenerator tempNameGenerator,
ITranslateIndividualStatements statementTranslator,
ITranslateValueSettingsStatements valueSettingStatementTranslator,
ILogInformation logger)
: base(supportRefName, envClassName, envRefName, outerClassName, outerRefName, nameRewriter, tempNameGenerator, statementTranslator, valueSettingStatementTranslator, logger)
{
}
public FuncByRefArgumentMapper(VBScriptNameRewriter nameRewriter, TempValueNameGenerator tempNameGenerator, ILogInformation logger)
{
if (tempNameGenerator == null)
{
throw new ArgumentNullException("tempNameGenerator");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_nameRewriter = nameRewriter;
_tempNameGenerator = tempNameGenerator;
_logger = logger;
}
private List <ILogInformation> CreateLogListFromBytes(byte[] parsedJournalData)
{
List <ILogInformation> logData = new List <ILogInformation>();
var longCurrentMessage = Encoding.Default.GetString(parsedJournalData.ToArray()).ToList();
for (int i = 0; i < longCurrentMessage.Count() - 46; i += 46)
{
var message = new String(longCurrentMessage.GetRange(i, 46).ToArray());
/*Разбор регулярным выражением*/
Regex regex = new Regex(@"\<(?<Date>.+)\>\<(?<Time>.+)\>\<(?<Message>.+)\>");
Match m = regex.Match(message);
string EventDate = string.Empty;
string EventTime = string.Empty;
string EventMessage;
DateTime JournalDateTime = new DateTime();
if (m.Success)
{
EventDate = m.Groups["Date"].Value;
EventTime = m.Groups["Time"].Value;
EventMessage = m.Groups["Message"].Value;
try
{
IFormatProvider culture = new System.Globalization.CultureInfo("en-US", true);
DateTime f1 = DateTime.ParseExact(EventDate, "dd/MM/yyyy", culture);
DateTime f2 = DateTime.Parse(EventTime, culture,
System.Globalization.DateTimeStyles.AssumeLocal);
JournalDateTime = new DateTime(f1.Year, f1.Month, f1.Day, f2.Hour, f2.Minute, f2.Second);
}
catch (Exception)
{
EventMessage = "Ошибка преобразования сообщения";
}
}
else
{
EventMessage = "Ошибка преобразования сообщения";
}
ILogInformation logInformation = _logInfoCreator();
logInformation.ActionDate = JournalDateTime;
logInformation.ActionDescription = EventMessage;
logData.Add(logInformation);
}
return(logData);
}
public ValueSettingStatementsTranslator(
CSharpName supportRefName,
CSharpName envRefName,
CSharpName outerRefName,
VBScriptNameRewriter nameRewriter,
ITranslateIndividualStatements statementTranslator,
ILogInformation logger)
{
if (supportRefName == null)
{
throw new ArgumentNullException("supportRefName");
}
if (envRefName == null)
{
throw new ArgumentNullException("envRefName");
}
if (outerRefName == null)
{
throw new ArgumentNullException("outerRefName");
}
if (nameRewriter == null)
{
throw new ArgumentNullException("nameRewriter");
}
if (statementTranslator == null)
{
throw new ArgumentNullException("statementTranslator");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_supportRefName = supportRefName;
_envRefName = envRefName;
_outerRefName = outerRefName;
_nameRewriter = nameRewriter;
_statementTranslator = statementTranslator;
_logger = logger;
}
private EventLog Map(ILogInformation info)
{
EventLog e = null;
if (info != null)
{
e = new EventLog();
e.Message = info.Message;
e.Origin = info.Origin;
e.Type = info.Type.ToString();
e.Category = info.Category;
e.ActivityID = info.ActivityID?.ToString();
if (info.Exception != null)
{
e.Exception = Newtonsoft.Json.JsonConvert.SerializeObject(info.Exception, JsonSettings.FriendlySerializationSettings);
}
e.Data = info.DataSerialized;
e.CreationDate = info.CreationDate;
e.UserName = info.UserName;
}
return(e);
}
protected override void ProtectedLog(ILogInformation info)
{
throw new NotImplementedException();
}
public void Log(ILogInformation info)
{
LogMethod(info);
}
/// <summary>
/// This Translate signature is what the others call into - it doesn't try to hide the fact that externalDependencies should be a NonNullImmutableList
/// of strings and it requires an ILogInformation implementation to deal with logging warnings
/// </summary>
public static NonNullImmutableList <TranslatedStatement> Translate(
string scriptContent,
NonNullImmutableList <string> externalDependencies,
OuterScopeBlockTranslator.OutputTypeOptions outputType,
ILogInformation logger)
{
if (scriptContent == null)
{
throw new ArgumentNullException("scriptContent");
}
if (externalDependencies == null)
{
throw new ArgumentNullException("externalDependencies");
}
if ((outputType != OuterScopeBlockTranslator.OutputTypeOptions.Executable) && (outputType != OuterScopeBlockTranslator.OutputTypeOptions.WithoutScaffolding))
{
throw new ArgumentOutOfRangeException("outputType");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
var startNamespace = new CSharpName("TranslatedProgram");
var startClassName = new CSharpName("Runner");
var startMethodName = new CSharpName("Go");
var runtimeDateLiteralValidatorClassName = new CSharpName("RuntimeDateLiteralValidator");
var supportRefName = new CSharpName("_");
var envClassName = new CSharpName("EnvironmentReferences");
var envRefName = new CSharpName("_env");
var outerClassName = new CSharpName("GlobalReferences");
var outerRefName = new CSharpName("_outer");
VBScriptNameRewriter nameRewriter = name => new CSharpName(DefaultRuntimeSupportClassFactory.DefaultNameRewriter(name.Content));
var tempNameGeneratorNextNumber = 0;
TempValueNameGenerator tempNameGenerator = (optionalPrefix, scopeAccessInformation) =>
{
// To get unique names for any given translation, a running counter is maintained and appended to the end of the generated
// name. This is only run during translation (this code is not used during execution) so there will be a finite number of
// times that this is called (so there should be no need to worry about the int value overflowing!)
return(new CSharpName(((optionalPrefix == null) ? "temp" : optionalPrefix.Name) + (++tempNameGeneratorNextNumber).ToString()));
};
var statementTranslator = new StatementTranslator(supportRefName, envRefName, outerRefName, nameRewriter, tempNameGenerator, logger);
var codeBlockTranslator = new OuterScopeBlockTranslator(
startNamespace,
startClassName,
startMethodName,
runtimeDateLiteralValidatorClassName,
supportRefName,
envClassName,
envRefName,
outerClassName,
outerRefName,
nameRewriter,
tempNameGenerator,
statementTranslator,
new ValueSettingStatementsTranslator(supportRefName, envRefName, outerRefName, nameRewriter, statementTranslator, logger),
externalDependencies.Select(name => new NameToken(name, 0)).ToNonNullImmutableList(),
outputType,
logger
);
return(codeBlockTranslator.Translate(
Parse(scriptContent).ToNonNullImmutableList()
));
}
protected override void ProtectedLog(ILogInformation info)
{
}
public void Log(ILogInformation info)
{
Debug.Print(info.ToString());
ProtectedLog(info);
}
protected override void ProtectedLog(ILogInformation info)
{
info.Category = _categoryName;
EventLogger.Instance.Log(info);
}
protected override void ProtectedLog(ILogInformation info)
{
_batchProcessor.Add(info);
}
protected abstract void ProtectedLog(ILogInformation info);
