private void Initialize(string configFileName)
{
try
{
var config = Config.Load(configFileName);
string validationText = config.ValidateErrors();
if (validationText == null)
{
m_currentConfig = config;
competitionCode.Text = config.CompetitionCode;
m_db = new Database(m_currentConfig);
m_scoresRepo = new QualificationScoresRepo(m_db);
m_tournamentRepo = new TournamentRepo(m_db);
m_Writer = WriterFactory.GetWriter(m_currentConfig);
GenerateNow.Enabled = true;
startPublishing.Enabled = true;
}
else
{
MessageBox.Show($"Config file validation failed.\r\n{validationText}");
}
}
catch (Exception ex)
{
MessageBox.Show($"Unable to open file.\n\r{ex.ToString()}");
}
}
static void Main(string[] args)
{
var writerName = System.Configuration.ConfigurationManager.AppSettings.Get("writer");
var writer = WriterFactory.GetWriter(writerName);
writer.Write();
System.Console.ReadLine();
}
public void GetWriterTest()
{
var expectedType = WriterType.CONSOLE;
var factory = new WriterFactory();
var writer = factory.GetWriter(expectedType);
var actualType = writer.Type;
Assert.AreEqual(expectedType, actualType);
Assert.True(writer is ConsoleWriter);
}
public void ConsoleWriterWritesWOException()
{
var writer = WriterFactory.GetWriter("CW.API.ConsoleWriter,CW.API");
try
{
writer.Write("test");
}
catch (Exception ex)
{
Assert.Fail("Expected no exception, but got: " + ex.Message);
}
}
private bool SelectWriter()
{
try
{
string newWriterSelection;
if (radioButtonHugoWriter.Checked)
{
newWriterSelection = "Hugo";
}
else
{
newWriterSelection = "Log";
}
if (newWriterSelection != m_writerSelection)
{
if (m_writer != null)
{
m_writer.OnInfo -= new LoggingEventHandler(Utilities_OnInfo);
m_writer.OnError -= new LoggingEventHandler(Utilities_OnError);
m_writer.OnWriterStopped -= new ServiceStoppedEventHandler(ReportListenerLib_OnWriterStopped);
}
m_writer = WriterFactory.GetWriter(newWriterSelection);
m_writerSelection = newWriterSelection;
if (m_writer != null)
{
m_writer.OnInfo += new LoggingEventHandler(Utilities_OnInfo);
m_writer.OnError += new LoggingEventHandler(Utilities_OnError);
m_writer.OnWriterStopped += new ServiceStoppedEventHandler(ReportListenerLib_OnWriterStopped);
}
}
}
catch (Exception ex)
{
DisplayErrorMessage("Unable to initialize writer", ex);
}
return(m_writer != null);
}
private bool SelectWriter(string writer)
{
try
{
m_writer = WriterFactory.GetWriter(writer);
if (m_writer == null)
{
OnInfo(String.Format("Unable to instantiate corporate actions writer {0}", writer));
return(false);
}
else
{
m_writer.OnInfo += new EventHandler <LoggingEventArgs>(CorporateActionsLib_OnInfo);
m_writer.OnError += new EventHandler <LoggingEventArgs>(CorporateActionsLib_OnError);
return(true);
}
}
catch (Exception ex)
{
OnError("Unable to instantiate report writer", ex);
return(false);
}
}
private bool SelectWriter(string writer)
{
try
{
m_writer = WriterFactory.GetWriter(writer);
if (m_writer == null)
{
LogInfoMessage(String.Format("Unable to instantiate report writer {0}", writer), true);
return(false);
}
else
{
m_writer.OnInfo += new LoggingEventHandler(Utilities_OnInfo);
m_writer.OnError += new LoggingEventHandler(Utilities_OnError);
m_writer.OnWriterStopped += new ServiceStoppedEventHandler(ReportListenerLib_OnWriterStopped);
return(true);
}
}
catch (Exception ex)
{
LogErrorMessage("Unable to instantiate report writer", ex, true);
return(false);
}
}
public int RunFileEntries(IEnumerable <FileEntry> fileListing, StreamWriter?outputStreamWriter = null)
{
Verifier?verifier = null;
if (_rulespath.Length > 0)
{
// Setup the rules
verifier = new Verifier(_rulespath);
if (!verifier.Verify())
{
return((int)ExitCode.CriticalError);
}
if (verifier.CompiledRuleset.Count() == 0 && _ignoreDefaultRules)
{
Debug.WriteLine("Error: No rules were loaded. ");
return((int)ExitCode.CriticalError);
}
}
RuleSet rules = new RuleSet();
if (verifier != null)
{
rules = verifier.CompiledRuleset;
}
if (!_ignoreDefaultRules)
{
Assembly?assembly = Assembly.GetAssembly(typeof(Boundary));
string filePath = "Microsoft.DevSkim.Resources.devskim-rules.json";
Stream? resource = assembly?.GetManifestResourceStream(filePath);
if (resource is Stream)
{
using (StreamReader file = new StreamReader(resource))
{
var rulesString = file.ReadToEnd();
rules.AddString(rulesString, filePath, null);
}
}
}
// Initialize the processor
RuleProcessor processor = new RuleProcessor(rules);
processor.EnableSuppressions = !_disableSuppression;
if (_severities.Count() > 0)
{
processor.SeverityLevel = 0;
foreach (string severityText in _severities)
{
Severity severity;
if (ParseSeverity(severityText, out severity))
{
processor.SeverityLevel |= severity;
}
else
{
Debug.WriteLine("Invalid severity: {0}", severityText);
return((int)ExitCode.CriticalError);
}
}
}
Writer outputWriter = WriterFactory.GetWriter(string.IsNullOrEmpty(_fileFormat) ? string.IsNullOrEmpty(_outputFile) ? "_dummy" : "text" : _fileFormat,
_outputFormat,
(outputStreamWriter is null)?(string.IsNullOrEmpty(_outputFile) ? Console.Out : File.CreateText(_outputFile)):outputStreamWriter,
(outputStreamWriter is null)?_outputFile:null);
int filesAnalyzed = 0;
int filesSkipped = 0;
int filesAffected = 0;
int issuesCount = 0;
void parseFileEntry(FileEntry fileEntry)
{
string language = Language.FromFileName(fileEntry.FullPath);
// Skip files written in unknown language
if (string.IsNullOrEmpty(language))
{
Interlocked.Increment(ref filesSkipped);
}
else
{
string fileText = string.Empty;
try
{
using (StreamReader reader = new StreamReader(fileEntry.Content))
{
fileText = reader.ReadToEnd();
}
Interlocked.Increment(ref filesAnalyzed);
}
catch (Exception)
{
// Skip files we can't parse
Interlocked.Increment(ref filesSkipped);
return;
}
Issue[] issues = processor.Analyze(fileText, language);
bool issuesFound = issues.Any(iss => !iss.IsSuppressionInfo) || _disableSuppression && issues.Any();
if (issuesFound)
{
Interlocked.Increment(ref filesAffected);
Debug.WriteLine("file:{0}", fileEntry.FullPath);
// Iterate through each issue
foreach (Issue issue in issues)
{
if (!issue.IsSuppressionInfo || _disableSuppression)
{
Interlocked.Increment(ref issuesCount);
Debug.WriteLine("\tregion:{0},{1},{2},{3} - {4} [{5}] - {6}",
issue.StartLocation.Line,
issue.StartLocation.Column,
issue.EndLocation.Line,
issue.EndLocation.Column,
issue.Rule.Id,
issue.Rule.Severity,
issue.Rule.Name);
IssueRecord record = new IssueRecord(
Filename: fileEntry.FullPath,
Filesize: fileText.Length,
TextSample: fileText.Substring(issue.Boundary.Index, issue.Boundary.Length),
Issue: issue,
Language: language);
outputWriter.WriteIssue(record);
}
}
}
}
}
//Iterate through all files
if (_disableParallel)
{
foreach (var fileEntry in fileListing)
{
parseFileEntry(fileEntry);
}
}
else
{
Parallel.ForEach(fileListing, parseFileEntry);
}
outputWriter.FlushAndClose();
Debug.WriteLine("Issues found: {0} in {1} files", issuesCount, filesAffected);
Debug.WriteLine("Files analyzed: {0}", filesAnalyzed);
Debug.WriteLine("Files skipped: {0}", filesSkipped);
return((int)ExitCode.NoIssues);
}
public int Run()
{
if (!Directory.Exists(_path) && !File.Exists(_path))
{
Console.Error.WriteLine("Error: Not a valid file or directory {0}", _path);
return((int)ExitCode.CriticalError);
}
Verifier verifier = null;
if (_rulespath.Count() > 0)
{
// Setup the rules
verifier = new Verifier(_rulespath);
if (!verifier.Verify())
{
return((int)ExitCode.CriticalError);
}
if (verifier.CompiledRuleset.Count() == 0 && _ignoreDefaultRules)
{
Console.Error.WriteLine("Error: No rules were loaded. ");
return((int)ExitCode.CriticalError);
}
}
RuleSet rules = new RuleSet();
if (verifier != null)
{
rules = verifier.CompiledRuleset;
}
if (!_ignoreDefaultRules)
{
Assembly assembly = Assembly.GetExecutingAssembly();
string filePath = "Microsoft.DevSkim.CLI.Resources.devskim-rules.json";
Stream resource = assembly.GetManifestResourceStream(filePath);
using (StreamReader file = new StreamReader(resource))
{
rules.AddString(file.ReadToEnd(), filePath, null);
}
}
// Initialize the processor
RuleProcessor processor = new RuleProcessor(rules);
if (_severities.Count() > 0)
{
processor.SeverityLevel = 0;
foreach (string severityText in _severities)
{
Severity severity;
if (ParseSeverity(severityText, out severity))
{
processor.SeverityLevel |= severity;
}
else
{
Console.Error.WriteLine("Invalid severity: {0}", severityText);
return((int)ExitCode.CriticalError);
}
}
}
Writer outputWriter = WriterFactory.GetWriter(_fileFormat,
(string.IsNullOrEmpty(_outputFile)) ? null : "text",
_outputFormat);
if (string.IsNullOrEmpty(_outputFile))
{
outputWriter.TextWriter = Console.Out;
}
else
{
outputWriter.TextWriter = File.CreateText(_outputFile);
}
int filesAnalyzed = 0;
int filesSkipped = 0;
int filesAffected = 0;
int issuesCount = 0;
// Iterate through all files
foreach (string filename in Directory.EnumerateFiles(_path, "*.*", SearchOption.AllDirectories))
{
string language = Language.FromFileName(filename);
// Skip files written in unknown language
if (string.IsNullOrEmpty(language))
{
filesSkipped++;
continue;
}
filesAnalyzed++;
string fileText = File.ReadAllText(filename);
Issue[] issues = processor.Analyze(fileText, language);
if (issues.Count() > 0)
{
filesAffected++;
issuesCount += issues.Count();
Console.Error.WriteLine("file:{0}", filename);
// Iterate through each issue
foreach (Issue issue in issues)
{
Console.Error.WriteLine("\tregion:{0},{1},{2},{3} - {4} [{5}] - {6}",
issue.StartLocation.Line,
issue.StartLocation.Column,
issue.EndLocation.Line,
issue.EndLocation.Column,
issue.Rule.Id,
issue.Rule.Severity,
issue.Rule.Name);
IssueRecord record = new IssueRecord()
{
Filename = filename,
Filesize = fileText.Length,
TextSample = fileText.Substring(issue.Boundary.Index, issue.Boundary.Length),
Issue = issue
};
outputWriter.WriteIssue(record);
}
Console.Error.WriteLine();
}
}
outputWriter.FlushAndClose();
Console.Error.WriteLine("Issues found: {0} in {1} files", issuesCount, filesAffected);
Console.Error.WriteLine("Files analyzed: {0}", filesAnalyzed);
Console.Error.WriteLine("Files skipped: {0}", filesSkipped);
return((int)ExitCode.NoIssues);
}
public void WriterFactoryReturnsCorrectWriter()
{
var writer = WriterFactory.GetWriter("CW.API.ConsoleWriter,CW.API");
Assert.IsInstanceOfType(writer, typeof(IWriter));
}
public void WrongClassThrowsException()
{
var writer = WriterFactory.GetWriter("Test");
}
public void ValidDBWriter()
{
WriterFactory w = new WriterFactory("DB");
Assert.IsInstanceOfType(w.GetWriter(), typeof(Writers.DBWriter));
}
public void ValidFileWriter()
{
WriterFactory w = new WriterFactory("File");
Assert.IsInstanceOfType(w.GetWriter(), typeof(Writers.FileWriter));
}
public int Run()
{
if (_suppressError)
{
Console.SetError(StreamWriter.Null);
}
if (!Directory.Exists(_path) && !File.Exists(_path))
{
Console.Error.WriteLine("Error: Not a valid file or directory {0}", _path);
return((int)ExitCode.CriticalError);
}
Verifier?verifier = null;
if (_rulespath.Count() > 0)
{
// Setup the rules
verifier = new Verifier(_rulespath);
if (!verifier.Verify())
{
return((int)ExitCode.CriticalError);
}
if (verifier.CompiledRuleset.Count() == 0 && _ignoreDefaultRules)
{
Console.Error.WriteLine("Error: No rules were loaded. ");
return((int)ExitCode.CriticalError);
}
}
RuleSet rules = new RuleSet();
if (verifier != null)
{
rules = verifier.CompiledRuleset;
}
if (!_ignoreDefaultRules)
{
Assembly?assembly = Assembly.GetAssembly(typeof(Boundary));
string filePath = "Microsoft.DevSkim.Resources.devskim-rules.json";
Stream? resource = assembly?.GetManifestResourceStream(filePath);
if (resource is Stream)
{
using (StreamReader file = new StreamReader(resource))
{
rules.AddString(file.ReadToEnd(), filePath, null);
}
}
}
// Initialize the processor
RuleProcessor processor = new RuleProcessor(rules);
processor.EnableSuppressions = !_disableSuppression;
if (_severities.Count() > 0)
{
processor.SeverityLevel = 0;
foreach (string severityText in _severities)
{
Severity severity;
if (ParseSeverity(severityText, out severity))
{
processor.SeverityLevel |= severity;
}
else
{
Console.Error.WriteLine("Invalid severity: {0}", severityText);
return((int)ExitCode.CriticalError);
}
}
}
Writer outputWriter = WriterFactory.GetWriter(string.IsNullOrEmpty(_fileFormat) ? string.IsNullOrEmpty(_outputFile) ? "_dummy" : "text" : _fileFormat,
_outputFormat,
(string.IsNullOrEmpty(_outputFile) ? Console.Out : File.CreateText(_outputFile)),
_outputFile);
int filesAnalyzed = 0;
int filesSkipped = 0;
int filesAffected = 0;
int issuesCount = 0;
// We can pass either a file or a directory; if it's a file, make an IEnumerable out of it.
IEnumerable <FileEntry> fileListing;
var extractor = new Extractor(new ExtractorOptions()
{
ExtractSelfOnFail = false
});
if (!Directory.Exists(_path))
{
fileListing = extractor.ExtractFile(_path);
}
else
{
fileListing = Directory.EnumerateFiles(_path, "*.*", SearchOption.AllDirectories).SelectMany(x => _crawlArchives ? extractor.ExtractFile(x) : FilenameToFileEntryArray(x));
}
// Iterate through all files
foreach (FileEntry fileEntry in fileListing)
{
string language = Language.FromFileName(fileEntry.FullPath);
// Skip files written in unknown language
if (string.IsNullOrEmpty(language))
{
filesSkipped++;
continue;
}
string fileText = string.Empty;
try
{
using (StreamReader reader = new StreamReader(fileEntry.Content))
{
fileText = reader.ReadToEnd();
}
filesAnalyzed++;
}
catch (Exception)
{
// Skip files we can't parse
filesSkipped++;
continue;
}
Issue[] issues = processor.Analyze(fileText, language);
bool issuesFound = issues.Any(iss => iss.IsSuppressionInfo == false) || _disableSuppression && issues.Count() > 0;
if (issuesFound)
{
filesAffected++;
Console.Error.WriteLine("file:{0}", fileEntry.FullPath);
// Iterate through each issue
foreach (Issue issue in issues)
{
if (!issue.IsSuppressionInfo || _disableSuppression)
{
issuesCount++;
Console.Error.WriteLine("\tregion:{0},{1},{2},{3} - {4} [{5}] - {6}",
issue.StartLocation.Line,
issue.StartLocation.Column,
issue.EndLocation.Line,
issue.EndLocation.Column,
issue.Rule.Id,
issue.Rule.Severity,
issue.Rule.Name);
IssueRecord record = new IssueRecord(
Filename: fileEntry.FullPath,
Filesize: fileText.Length,
TextSample: fileText.Substring(issue.Boundary.Index, issue.Boundary.Length),
Issue: issue,
Language: language);
outputWriter.WriteIssue(record);
}
}
Console.Error.WriteLine();
}
}
outputWriter.FlushAndClose();
Console.Error.WriteLine("Issues found: {0} in {1} files", issuesCount, filesAffected);
Console.Error.WriteLine("Files analyzed: {0}", filesAnalyzed);
Console.Error.WriteLine("Files skipped: {0}", filesSkipped);
return((int)ExitCode.NoIssues);
}
